Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
multi_buffer: Fix word diff ranges for collapsed hunks (#65829)
Arth Srivastava32558ab9d531
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rsindex 5d60d65b229..0787f0078d0 100644--- a/crates/multi_buffer/src/multi_buffer.rs+++ b/crates/multi_buffer/src/multi_buffer.rs@@ -3519,18 +3519,29 @@ impl MultiBufferSnapshot {.then(|| {let mut word_diffs = Vec::new();- if self.show_deleted_hunks || is_inverted {- let hunk_start_offset = if is_inverted {- Anchor::in_buffer(- excerpt.path_key_index,- buffer_snapshot.anchor_after(hunk.diff_base_byte_range.start),- )+ let hunk_start_offset = if is_inverted {+ Anchor::in_buffer(+ excerpt.path_key_index,+ buffer_snapshot.anchor_after(hunk.diff_base_byte_range.start),+ )+ .to_offset(self)+ } else {+ Anchor::in_buffer(excerpt.path_key_index, hunk.buffer_range.start).to_offset(self)- } else {- Anchor::in_buffer(excerpt.path_key_index, hunk.buffer_range.start)- .to_offset(self)- };+ };++ let hunk_has_deleted_text = !is_inverted && {+ let mut cursor = self.diff_transforms.cursor::<MultiBufferOffset>(());+ cursor.seek(&hunk_start_offset, Bias::Right);+ matches!(+ cursor.item(),+ Some(DiffTransform::DeletedHunk { buffer_id, hunk_info, .. })+ if *buffer_id == buffer_snapshot.remote_id()+ && hunk_info.hunk_start_anchor == hunk.buffer_range.start+ )+ };+ if hunk_has_deleted_text || is_inverted {word_diffs.extend(hunk.base_word_diffs.iter().map(|diff| {hunk_start_offset + diff.start..hunk_start_offset + diff.end}));diff --git a/crates/multi_buffer/src/multi_buffer_tests.rs b/crates/multi_buffer/src/multi_buffer_tests.rsindex 397cf00be11..e0e20ac88aa 100644--- a/crates/multi_buffer/src/multi_buffer_tests.rs+++ b/crates/multi_buffer/src/multi_buffer_tests.rs@@ -13,11 +13,6 @@ use util::RandomCharIter;use util::rel_path::rel_path;use util::test::sample_text;-#[ctor::ctor(unsafe)]-fn init_logger() {- zlog::init_test();-}-#[gpui::test]fn test_empty_singleton(cx: &mut App) {let buffer = cx.new(|cx| Buffer::local("", cx));@@ -3398,2667 +3393,1869 @@ async fn test_diff_hunks_with_multiple_excerpts(cx: &mut TestAppContext) {assert_line_indents(&snapshot);}-/// A naive implementation of a multi-buffer that does not maintain-/// any derived state, used for comparison in a randomized test.-#[derive(Default)]-struct ReferenceMultibuffer {- excerpts: Vec<ReferenceExcerpt>,- diffs: HashMap<BufferId, Entity<BufferDiff>>,- inverted_diffs: HashMap<BufferId, (Entity<BufferDiff>, Entity<language::Buffer>)>,- expanded_diff_hunks_by_buffer: HashMap<BufferId, Vec<text::Anchor>>,-}+#[gpui::test(iterations = 100)]+async fn test_random_set_ranges(cx: &mut TestAppContext, mut rng: StdRng) {+ let base_text = "a\n".repeat(100);+ let buf = cx.update(|cx| cx.new(|cx| Buffer::local(base_text, cx)));+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));-#[derive(Clone, Debug)]-struct ReferenceExcerpt {- path_key: PathKey,- path_key_index: PathKeyIndex,- buffer: Entity<Buffer>,- range: Range<text::Anchor>,-}+ let operations = env::var("OPERATIONS")+ .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))+ .unwrap_or(10);-#[derive(Clone, Debug)]-struct ReferenceRegion {- buffer_id: Option<BufferId>,- range: Range<usize>,- buffer_range: Range<Point>,- // if this is a deleted hunk, the main buffer anchor to which the deleted content is attached- deleted_hunk_anchor: Option<text::Anchor>,- status: Option<DiffHunkStatus>,- excerpt: Option<ReferenceExcerpt>,-}+ fn row_ranges(ranges: &Vec<Range<Point>>) -> Vec<Range<u32>> {+ ranges+ .iter()+ .map(|range| range.start.row..range.end.row)+ .collect()+ }-impl ReferenceMultibuffer {- fn expand_excerpts(- &mut self,- excerpts: &HashSet<ExcerptRange<text::Anchor>>,- line_count: u32,- cx: &mut App,- ) {- use text::AnchorRangeExt as _;+ for _ in 0..operations {+ let snapshot = buf.update(cx, |buf, _| buf.snapshot());+ let num_ranges = rng.random_range(0..=10);+ let max_row = snapshot.max_point().row;+ let mut ranges = (0..num_ranges)+ .map(|_| {+ let start = rng.random_range(0..max_row);+ let end = rng.random_range(start + 1..max_row + 1);+ Point::row_range(start..end)+ })+ .collect::<Vec<_>>();+ ranges.sort_by_key(|range| range.start);+ log::info!("Setting ranges: {:?}", row_ranges(&ranges));+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ PathKey::for_buffer(&buf, cx),+ buf.clone(),+ ranges.clone(),+ 2,+ cx,+ )+ });- if line_count == 0 || excerpts.is_empty() {- return;- }+ let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ let mut last_end = None;+ let mut seen_ranges = Vec::default();- let mut excerpts_by_buffer: HashMap<BufferId, Vec<ExcerptRange<text::Anchor>>> =- HashMap::default();- for excerpt in excerpts {- excerpts_by_buffer- .entry(excerpt.context.start.buffer_id)- .or_default()- .push(excerpt.clone())- }+ for info in snapshot.excerpts() {+ let buffer_snapshot = snapshot+ .buffer_for_id(info.context.start.buffer_id)+ .unwrap();+ let start = info.context.start.to_point(buffer_snapshot);+ let end = info.context.end.to_point(buffer_snapshot);+ seen_ranges.push(start..end);- for (buffer_id, excerpts_to_expand) in excerpts_by_buffer {- let mut buffer = None;- let mut buffer_snapshot = None;- let mut path = None;- let mut path_key_index = None;- let mut new_ranges =- self.excerpts- .iter()- .filter(|excerpt| excerpt.range.start.buffer_id == buffer_id)- .map(|excerpt| {- let snapshot = excerpt.buffer.read(cx).snapshot();- let mut range = excerpt.range.to_point(&snapshot);- if excerpts_to_expand.iter().any(|info| {- excerpt.range.contains_anchor(info.context.start, &snapshot)- }) {- range.start = Point::new(range.start.row.saturating_sub(line_count), 0);- range.end = snapshot- .clip_point(Point::new(range.end.row + line_count, 0), Bias::Left);- range.end.column = snapshot.line_len(range.end.row);- }- buffer = Some(excerpt.buffer.clone());- buffer_snapshot = Some(snapshot);- path = Some(excerpt.path_key.clone());- path_key_index = Some(excerpt.path_key_index);- ExcerptRange::new(range)- })- .collect::<Vec<_>>();+ if let Some(last_end) = last_end.take() {+ assert!(+ start > last_end,+ "multibuffer has out-of-order ranges: {:?}; {:?} <= {:?}",+ row_ranges(&seen_ranges),+ start,+ last_end+ )+ }- new_ranges.sort_by_key(|nr| nr.context.start);+ ranges.retain(|range| range.start < start || range.end > end);- self.set_excerpts(- path.unwrap(),- path_key_index.unwrap(),- buffer.unwrap(),- &buffer_snapshot.unwrap(),- new_ranges,- cx,- );+ last_end = Some(end)}- }- fn set_excerpts(- &mut self,- path_key: PathKey,- path_key_index: PathKeyIndex,- buffer: Entity<Buffer>,- buffer_snapshot: &BufferSnapshot,- ranges: Vec<ExcerptRange<Point>>,- cx: &mut App,- ) {- self.excerpts.retain(|excerpt| {- excerpt.path_key != path_key && excerpt.buffer.entity_id() != buffer.entity_id()- });-- let ranges = MultiBuffer::merge_excerpt_ranges(&ranges);-- let (Ok(ix) | Err(ix)) = self- .excerpts- .binary_search_by(|probe| probe.path_key.cmp(&path_key));- self.excerpts.splice(- ix..ix,- ranges.into_iter().map(|range| ReferenceExcerpt {- path_key: path_key.clone(),- path_key_index,- buffer: buffer.clone(),- range: buffer_snapshot.anchor_before(range.context.start)- ..buffer_snapshot.anchor_after(range.context.end),- }),+ assert!(+ ranges.is_empty(),+ "multibuffer {:?} did not include all ranges: {:?}",+ row_ranges(&seen_ranges),+ row_ranges(&ranges));- self.update_expanded_diff_hunks_for_buffer(buffer_snapshot.remote_id(), cx);}+}- fn expand_diff_hunks(&mut self, path_key: PathKey, range: Range<text::Anchor>, cx: &App) {- let excerpt = self- .excerpts- .iter_mut()- .find(|e| {- e.path_key == path_key- && e.range- .start- .cmp(&range.start, &e.buffer.read(cx).snapshot())- .is_le()- && e.range- .end- .cmp(&range.end, &e.buffer.read(cx).snapshot())- .is_ge()- })- .unwrap();- let buffer = excerpt.buffer.read(cx).snapshot();- let buffer_id = buffer.remote_id();+#[gpui::test(iterations = 100)]+async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {+ let operations = env::var("OPERATIONS")+ .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))+ .unwrap_or(10);+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+ let mut buffers: Vec<Entity<Buffer>> = Vec::new();+ let mut base_texts: HashMap<BufferId, String> = HashMap::default();+ let mut reference = ReferenceMultibuffer::default();+ let mut anchors = Vec::new();+ let mut old_versions = Vec::new();+ let mut needs_diff_calculation = false;+ let mut inverted_diff_main_buffers: HashMap<BufferId, Entity<BufferDiff>> = HashMap::default();+ for _ in 0..operations {+ match rng.random_range(0..100) {+ 0..=14 if !buffers.is_empty() => {+ let buffer = buffers.choose(&mut rng).unwrap();+ buffer.update(cx, |buf, cx| {+ let edit_count = rng.random_range(1..5);+ buf.randomly_edit(&mut rng, edit_count, cx);+ log::info!("buffer text:\n{}", buf.text());+ needs_diff_calculation = true;+ });+ cx.update(|cx| reference.diffs_updated(cx));+ }+ 15..=24 if !reference.excerpts.is_empty() => {+ multibuffer.update(cx, |multibuffer, cx| {+ let snapshot = multibuffer.snapshot(cx);+ let infos = snapshot.excerpts().collect::<Vec<_>>();+ let mut excerpts = HashSet::default();+ for _ in 0..rng.random_range(0..infos.len()) {+ excerpts.extend(infos.choose(&mut rng).cloned());+ }- // Skip inverted excerpts - hunks are always expanded- if self.inverted_diffs.contains_key(&buffer_id) {- return;- }+ let line_count = rng.random_range(0..5);- let Some(diff) = self.diffs.get(&buffer_id) else {- return;- };- let excerpt_range = excerpt.range.to_point(&buffer);- let expanded_diff_hunks = self- .expanded_diff_hunks_by_buffer- .entry(buffer_id)- .or_default();- for hunk in diff- .read(cx)- .snapshot(cx)- .hunks_intersecting_range(range, &buffer)- {- let hunk_range = hunk.buffer_range.to_point(&buffer);- if hunk_range.start < excerpt_range.start || hunk_range.start > excerpt_range.end {- continue;- }- if let Err(ix) = expanded_diff_hunks- .binary_search_by(|anchor| anchor.cmp(&hunk.buffer_range.start, &buffer))- {- log::info!(- "expanding diff hunk {:?}. excerpt range: {:?}, buffer {:?}",- hunk_range,- excerpt_range,- buffer.remote_id()+ let excerpt_ixs = excerpts+ .iter()+ .map(|info| {+ reference+ .excerpts+ .iter()+ .position(|e| e.range == info.context)+ .unwrap()+ })+ .collect::<Vec<_>>();+ log::info!("Expanding excerpts {excerpt_ixs:?} by {line_count} lines");+ multibuffer.expand_excerpts(+ excerpts+ .iter()+ .map(|info| snapshot.anchor_in_excerpt(info.context.end).unwrap()),+ line_count,+ ExpandExcerptDirection::UpAndDown,+ cx,+ );++ reference.expand_excerpts(&excerpts, line_count, cx);+ });+ }+ 25..=34 if !reference.excerpts.is_empty() => {+ let multibuffer =+ multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ let offset = multibuffer.clip_offset(+ MultiBufferOffset(rng.random_range(0..=multibuffer.len().0)),+ Bias::Left,);- expanded_diff_hunks.insert(ix, hunk.buffer_range.start);- } else {- log::trace!("hunk {hunk_range:?} already expanded in excerpt");+ let bias = if rng.random() {+ Bias::Left+ } else {+ Bias::Right+ };+ log::info!("Creating anchor at {} with bias {:?}", offset.0, bias);+ anchors.push(multibuffer.anchor_at(offset, bias));+ anchors.sort_by(|a, b| a.cmp(b, &multibuffer));}- }- }-- fn expected_content(- &self,- cx: &App,- ) -> (- String,- Vec<RowInfo>,- HashSet<MultiBufferRow>,- Vec<ReferenceRegion>,- ) {- use util::maybe;+ 35..=45 if !reference.excerpts.is_empty() => {+ multibuffer.update(cx, |multibuffer, cx| {+ let snapshot = multibuffer.snapshot(cx);+ let excerpt_ix = rng.random_range(0..reference.excerpts.len());+ let excerpt = &reference.excerpts[excerpt_ix];- let mut text = String::new();- let mut regions = Vec::<ReferenceRegion>::new();- let mut excerpt_boundary_rows = HashSet::default();- for excerpt in &self.excerpts {- excerpt_boundary_rows.insert(MultiBufferRow(text.matches('\n').count() as u32));- let buffer = excerpt.buffer.read(cx);- let buffer_id = buffer.remote_id();- let buffer_range = excerpt.range.to_offset(buffer);+ // Skip inverted excerpts - hunks can't be collapsed+ let buffer_id = excerpt.buffer.read(cx).remote_id();+ if reference.inverted_diffs.contains_key(&buffer_id) {+ return;+ }- if let Some((diff, main_buffer)) = self.inverted_diffs.get(&buffer_id) {- let diff_snapshot = diff.read(cx).snapshot(cx);- let main_buffer_snapshot = main_buffer.read(cx).snapshot();+ let start = excerpt.range.start;+ let end = excerpt.range.end;+ let range = snapshot.anchor_in_excerpt(start).unwrap()+ ..snapshot.anchor_in_excerpt(end).unwrap();- let mut offset = buffer_range.start;- for hunk in diff_snapshot.hunks_intersecting_base_text_range(- buffer_range.clone(),- &main_buffer_snapshot.text,- ) {- let mut hunk_base_range = hunk.diff_base_byte_range.clone();+ log::info!(+ "expanding diff hunks in range {:?} (excerpt index {excerpt_ix:?}, buffer id {:?})",+ range.to_point(&snapshot),+ buffer_id,+ );+ reference.expand_diff_hunks(excerpt.path_key.clone(), start..end, cx);+ multibuffer.expand_diff_hunks(vec![range], cx);+ });+ }+ 46..=75 if needs_diff_calculation => {+ multibuffer.update(cx, |multibuffer, cx| {+ for buffer in multibuffer.all_buffers() {+ let snapshot = buffer.read(cx).snapshot();+ let buffer_id = snapshot.remote_id();- hunk_base_range.end = hunk_base_range.end.min(buffer_range.end);- if hunk_base_range.start > buffer_range.end- || hunk_base_range.start < buffer_range.start- {- continue;- }+ if let Some(diff) = multibuffer.diff_for(buffer_id) {+ diff.update(cx, |diff, cx| {+ log::info!("recalculating diff for buffer {:?}", buffer_id,);+ diff.recalculate_diff_sync(&snapshot.text, cx);+ });+ }- // Add the text before the hunk- if hunk_base_range.start >= offset {- let len = text.len();- text.extend(buffer.text_for_range(offset..hunk_base_range.start));- if text.len() > len {- regions.push(ReferenceRegion {- buffer_id: Some(buffer_id),- range: len..text.len(),- buffer_range: (offset..hunk_base_range.start).to_point(&buffer),- status: None,- excerpt: Some(excerpt.clone()),- deleted_hunk_anchor: None,+ if let Some(inverted_diff) = inverted_diff_main_buffers.get(&buffer_id) {+ inverted_diff.update(cx, |diff, cx| {+ log::info!(+ "recalculating inverted diff for main buffer {:?}",+ buffer_id,+ );+ diff.recalculate_diff_sync(&snapshot.text, cx);});}}+ reference.diffs_updated(cx);+ needs_diff_calculation = false;+ });+ }+ _ => {+ // Decide if we're creating a new buffer or reusing an existing one+ let create_new_buffer = buffers.is_empty() || rng.random_bool(0.4);- // Add the "deleted" region (base text that's not in main)- if !hunk_base_range.is_empty() {- let len = text.len();- text.extend(buffer.text_for_range(hunk_base_range.clone()));- regions.push(ReferenceRegion {- buffer_id: Some(buffer_id),- range: len..text.len(),- buffer_range: hunk_base_range.to_point(&buffer),- status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),- excerpt: Some(excerpt.clone()),- deleted_hunk_anchor: None,- });- }+ let (excerpt_buffer, diff, inverted_main_buffer) = if create_new_buffer {+ let create_inverted = rng.random_bool(0.3);- offset = hunk_base_range.end;- }+ if create_inverted {+ let mut main_buffer_text = util::RandomCharIter::new(&mut rng)+ .take(256)+ .collect::<String>();+ let main_buffer = cx.new(|cx| Buffer::local(main_buffer_text.clone(), cx));+ text::LineEnding::normalize(&mut main_buffer_text);+ let main_buffer_id =+ main_buffer.read_with(cx, |buffer, _| buffer.remote_id());+ base_texts.insert(main_buffer_id, main_buffer_text.clone());+ buffers.push(main_buffer.clone());- // Add remaining buffer text- let len = text.len();- text.extend(buffer.text_for_range(offset..buffer_range.end));- text.push('\n');- regions.push(ReferenceRegion {- buffer_id: Some(buffer_id),- range: len..text.len(),- buffer_range: (offset..buffer_range.end).to_point(&buffer),- status: None,- excerpt: Some(excerpt.clone()),- deleted_hunk_anchor: None,- });- } else {- let diff = self.diffs.get(&buffer_id).unwrap().read(cx).snapshot(cx);- let base_buffer = diff.base_text();+ let diff = cx.new(|cx| {+ BufferDiff::new_with_base_text(+ &main_buffer_text,+ &main_buffer.read(cx).text_snapshot(),+ cx,+ )+ });- let mut offset = buffer_range.start;- let hunks = diff- .hunks_intersecting_range(excerpt.range.clone(), buffer)- .peekable();+ let base_text_buffer =+ diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());- for hunk in hunks {- // Ignore hunks that are outside the excerpt range.- let mut hunk_range = hunk.buffer_range.to_offset(buffer);+ // Track for recalculation when main buffer is edited+ inverted_diff_main_buffers.insert(main_buffer_id, diff.clone());- hunk_range.end = hunk_range.end.min(buffer_range.end);- if hunk_range.start > buffer_range.end || hunk_range.start < buffer_range.start- {- log::trace!("skipping hunk outside excerpt range");- continue;- }+ (base_text_buffer, diff, Some(main_buffer))+ } else {+ let mut base_text = util::RandomCharIter::new(&mut rng)+ .take(256)+ .collect::<String>();- if !self- .expanded_diff_hunks_by_buffer- .get(&buffer_id)- .cloned()- .into_iter()- .flatten()- .any(|expanded_anchor| {- expanded_anchor- .cmp(&hunk.buffer_range.start, buffer)- .is_eq()- })- {- log::trace!("skipping a hunk that's not marked as expanded");- continue;- }+ let buffer_handle = cx.new(|cx| Buffer::local(base_text.clone(), cx));+ text::LineEnding::normalize(&mut base_text);+ let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());+ base_texts.insert(buffer_id, base_text.clone());+ buffers.push(buffer_handle.clone());- if !hunk.buffer_range.start.is_valid(buffer) {- log::trace!("skipping hunk with deleted start: {:?}", hunk.range);- continue;+ let diff = cx.new(|cx| {+ BufferDiff::new_with_base_text(+ &base_text,+ &buffer_handle.read(cx).text_snapshot(),+ cx,+ )+ });++ (buffer_handle, diff, None)}+ } else {+ // Reuse an existing buffer+ let buffer_handle = buffers.choose(&mut rng).unwrap().clone();+ let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());- if hunk_range.start >= offset {- // Add the buffer text before the hunk- let len = text.len();- text.extend(buffer.text_for_range(offset..hunk_range.start));- if text.len() > len {- regions.push(ReferenceRegion {- buffer_id: Some(buffer_id),- range: len..text.len(),- buffer_range: (offset..hunk_range.start).to_point(&buffer),- status: None,- excerpt: Some(excerpt.clone()),- deleted_hunk_anchor: None,- });- }-- // Add the deleted text for the hunk.- if !hunk.diff_base_byte_range.is_empty() {- let mut base_text = base_buffer- .text_for_range(hunk.diff_base_byte_range.clone())- .collect::<String>();- if !base_text.ends_with('\n') {- base_text.push('\n');- }- let len = text.len();- text.push_str(&base_text);- regions.push(ReferenceRegion {- buffer_id: Some(base_buffer.remote_id()),- range: len..text.len(),- buffer_range: hunk.diff_base_byte_range.to_point(&base_buffer),- status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),- excerpt: Some(excerpt.clone()),- deleted_hunk_anchor: Some(hunk.buffer_range.start),+ if let Some(diff) = inverted_diff_main_buffers.get(&buffer_id) {+ let base_text_buffer =+ diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());+ (base_text_buffer, diff.clone(), Some(buffer_handle))+ } else {+ // Get existing diff or create new one for regular buffer+ let diff = multibuffer+ .read_with(cx, |mb, _| mb.diff_for(buffer_id))+ .unwrap_or_else(|| {+ let base_text = base_texts.get(&buffer_id).unwrap();+ cx.new(|cx| {+ BufferDiff::new_with_base_text(+ base_text,+ &buffer_handle.read(cx).text_snapshot(),+ cx,+ )+ })});- }-- offset = hunk_range.start;+ (buffer_handle, diff, None)}+ };- // Add the inserted text for the hunk.- if hunk_range.end > offset {- let len = text.len();- text.extend(buffer.text_for_range(offset..hunk_range.end));- let range = len..text.len();- let region = ReferenceRegion {- buffer_id: Some(buffer_id),- range,- buffer_range: (offset..hunk_range.end).to_point(&buffer),- status: Some(DiffHunkStatus::added(hunk.secondary_status)),- excerpt: Some(excerpt.clone()),- deleted_hunk_anchor: None,- };- offset = hunk_range.end;- regions.push(region);- }- }+ let excerpt_buffer_snapshot =+ excerpt_buffer.read_with(cx, |excerpt_buffer, _| excerpt_buffer.snapshot());+ let mut ranges = reference+ .excerpts+ .iter()+ .filter(|excerpt| excerpt.buffer == excerpt_buffer)+ .map(|excerpt| excerpt.range.to_point(&excerpt_buffer_snapshot))+ .collect::<Vec<_>>();+ mutate_excerpt_ranges(&mut rng, &mut ranges, &excerpt_buffer_snapshot, 1);+ let ranges = ranges+ .iter()+ .cloned()+ .map(ExcerptRange::new)+ .collect::<Vec<_>>();+ let path = cx.update(|cx| PathKey::for_buffer(&excerpt_buffer, cx));+ let path_key_index = multibuffer.update(cx, |multibuffer, _| {+ multibuffer.get_or_create_path_key_index(&path)+ });- // Add the buffer text for the rest of the excerpt.- let len = text.len();- text.extend(buffer.text_for_range(offset..buffer_range.end));- text.push('\n');- regions.push(ReferenceRegion {- buffer_id: Some(buffer_id),- range: len..text.len(),- buffer_range: (offset..buffer_range.end).to_point(&buffer),- status: None,- excerpt: Some(excerpt.clone()),- deleted_hunk_anchor: None,+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpt_ranges_for_path(+ path.clone(),+ excerpt_buffer.clone(),+ &excerpt_buffer_snapshot,+ ranges.clone(),+ cx,+ )});- }- }- // Remove final trailing newline.- if self.excerpts.is_empty() {- regions.push(ReferenceRegion {- buffer_id: None,- range: 0..1,- buffer_range: Point::new(0, 0)..Point::new(0, 1),- status: None,- excerpt: None,- deleted_hunk_anchor: None,- });- } else {- text.pop();- let region = regions.last_mut().unwrap();- assert!(region.deleted_hunk_anchor.is_none());- region.range.end -= 1;- }+ cx.update(|cx| {+ reference.set_excerpts(+ path,+ path_key_index,+ excerpt_buffer.clone(),+ &excerpt_buffer_snapshot,+ ranges,+ cx,+ )+ });- // Retrieve the row info using the region that contains- // the start of each multi-buffer line.- let mut ix = 0;- let row_infos = text- .split('\n')- .map(|line| {- let row_info = regions- .iter()- .rposition(|region| {- region.range.contains(&ix) || (ix == text.len() && ix == region.range.end)- })- .map_or(RowInfo::default(), |region_ix| {- let region = regions[region_ix].clone();- let buffer_row = region.buffer_range.start.row- + text[region.range.start..ix].matches('\n').count() as u32;- let main_buffer = region.excerpt.as_ref().map(|e| e.buffer.clone());- let excerpt_range = region.excerpt.as_ref().map(|e| &e.range);- let is_excerpt_start = region_ix == 0- || regions[region_ix - 1].excerpt.as_ref().map(|e| &e.range)- != excerpt_range- || regions[region_ix - 1].range.is_empty();- let mut is_excerpt_end = region_ix == regions.len() - 1- || regions[region_ix + 1].excerpt.as_ref().map(|e| &e.range)- != excerpt_range;- let is_start = !text[region.range.start..ix].contains('\n');- let is_last_region = region_ix == regions.len() - 1;- let mut is_end = if region.range.end > text.len() {- !text[ix..].contains('\n')+ let excerpt_buffer_id =+ excerpt_buffer.read_with(cx, |buffer, _| buffer.remote_id());+ multibuffer.update(cx, |multibuffer, cx| {+ if multibuffer.diff_for(excerpt_buffer_id).is_none() {+ if let Some(main_buffer) = inverted_main_buffer {+ reference.add_inverted_diff(diff.clone(), main_buffer.clone(), cx);+ multibuffer.add_inverted_diff(diff, main_buffer, cx);} else {- let remaining_newlines = text[ix..region.range.end.min(text.len())]- .matches('\n')- .count();- remaining_newlines == if is_last_region { 0 } else { 1 }- };- if region_ix < regions.len() - 1- && !text[ix..].contains("\n")- && (region.status == Some(DiffHunkStatus::added_none())- || region.status.is_some_and(|s| s.is_deleted()))- && regions[region_ix + 1].excerpt.as_ref().map(|e| &e.range)- == excerpt_range- && regions[region_ix + 1].range.start == text.len()- {- is_end = true;- is_excerpt_end = true;- }- let multibuffer_row =- MultiBufferRow(text[..ix].matches('\n').count() as u32);- let mut expand_direction = None;- if let Some(buffer) = &main_buffer {- let needs_expand_up = is_excerpt_start && is_start && buffer_row > 0;- let needs_expand_down = is_excerpt_end- && is_end- && buffer.read(cx).max_point().row > buffer_row;- expand_direction = if needs_expand_up && needs_expand_down {- Some(ExpandExcerptDirection::UpAndDown)- } else if needs_expand_up {- Some(ExpandExcerptDirection::Up)- } else if needs_expand_down {- Some(ExpandExcerptDirection::Down)- } else {- None- };+ reference.add_diff(diff.clone(), cx);+ multibuffer.add_diff(diff, cx);}- RowInfo {- buffer_id: region.buffer_id,- diff_status: region.status,- buffer_row: Some(buffer_row),- wrapped_buffer_row: None,+ }+ });+ }+ }- multibuffer_row: Some(multibuffer_row),- expand_info: maybe!({- let direction = expand_direction?;- let excerpt = region.excerpt.as_ref()?;- Some(ExpandInfo {- direction,- start_anchor: Anchor::in_buffer(- excerpt.path_key_index,- excerpt.range.start,- ),- })- }),- }- });- ix += line.len() + 1;- row_info+ if rng.random_bool(0.3) {+ multibuffer.update(cx, |multibuffer, cx| {+ old_versions.push((multibuffer.snapshot(cx), multibuffer.subscribe()));})- .collect();-- (text, row_infos, excerpt_boundary_rows, regions)- }-- fn diffs_updated(&mut self, cx: &mut App) {- let buffer_ids = self.diffs.keys().copied().collect::<Vec<_>>();- for buffer_id in buffer_ids {- self.update_expanded_diff_hunks_for_buffer(buffer_id, cx);}- }- fn add_diff(&mut self, diff: Entity<BufferDiff>, cx: &mut App) {- let buffer_id = diff.read(cx).buffer_id;- self.diffs.insert(buffer_id, diff);+ multibuffer.read_with(cx, |multibuffer, cx| {+ check_multibuffer(multibuffer, &reference, &anchors, cx, &mut rng);+ });}-- fn add_inverted_diff(- &mut self,- diff: Entity<BufferDiff>,- main_buffer: Entity<language::Buffer>,- cx: &App,- ) {- let base_text_buffer_id = diff.read(cx).base_text(cx).remote_id();- self.inverted_diffs- .insert(base_text_buffer_id, (diff, main_buffer));+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ for (old_snapshot, subscription) in old_versions {+ check_multibuffer_edits(&snapshot, &old_snapshot, subscription);}+}- fn update_expanded_diff_hunks_for_buffer(&mut self, buffer_id: BufferId, cx: &mut App) {- let excerpts = self- .excerpts- .iter()- .filter(|excerpt| excerpt.buffer.read(cx).remote_id() == buffer_id)- .collect::<Vec<_>>();- let Some(buffer) = excerpts.first().map(|excerpt| excerpt.buffer.clone()) else {- self.expanded_diff_hunks_by_buffer.remove(&buffer_id);- return;- };- let buffer_snapshot = buffer.read(cx).snapshot();- let Some(diff) = self.diffs.get(&buffer_id) else {- self.expanded_diff_hunks_by_buffer.remove(&buffer_id);- return;- };- let diff = diff.read(cx).snapshot(cx);- let hunks = diff- .hunks_in_row_range(0..u32::MAX, &buffer_snapshot)- .collect::<Vec<_>>();- self.expanded_diff_hunks_by_buffer- .entry(buffer_id)- .or_default()- .retain(|hunk_anchor| {- if !hunk_anchor.is_valid(&buffer_snapshot) {- return false;- }-- let Ok(ix) = hunks.binary_search_by(|hunk| {- hunk.buffer_range.start.cmp(hunk_anchor, &buffer_snapshot)- }) else {- return false;- };- let hunk_range = hunks[ix].buffer_range.to_point(&buffer_snapshot);- excerpts.iter().any(|excerpt| {- let excerpt_range = excerpt.range.to_point(&buffer_snapshot);- hunk_range.start >= excerpt_range.start && hunk_range.start <= excerpt_range.end- })- });- }+#[gpui::test]+fn test_history(cx: &mut App) {+ let test_settings = SettingsStore::test(cx);+ cx.set_global(test_settings);- fn anchor_to_offset(&self, anchor: &Anchor, cx: &App) -> Option<MultiBufferOffset> {- if anchor.diff_base_anchor().is_some() {- panic!("reference multibuffer cannot yet resolve anchors inside deleted hunks");- }- let (anchor, snapshot, path_key) = self.anchor_to_buffer_anchor(anchor, cx)?;- // TODO(cole) can maybe make this and expected content call a common function instead- let (text, _, _, regions) = self.expected_content(cx);+ let group_interval: Duration = Duration::from_millis(1);+ let buffer_1 = cx.new(|cx| {+ let mut buf = Buffer::local("1234", cx);+ buf.set_group_interval(group_interval);+ buf+ });+ let buffer_2 = cx.new(|cx| {+ let mut buf = Buffer::local("5678", cx);+ buf.set_group_interval(group_interval);+ buf+ });+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+ multibuffer.update(cx, |this, cx| {+ this.set_group_interval(group_interval, cx);+ });+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer_1.clone(),+ [Point::zero()..buffer_1.read(cx).max_point()],+ 0,+ cx,+ );+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(1),+ buffer_2.clone(),+ [Point::zero()..buffer_2.read(cx).max_point()],+ 0,+ cx,+ );+ });- // Locate the first region that contains or is past the putative location of the buffer anchor- let ix = regions.partition_point(|region| {- let excerpt = region- .excerpt- .as_ref()- .expect("should have no buffers in empty reference multibuffer");- excerpt- .path_key- .cmp(&path_key)- .then_with(|| {- if excerpt.range.end.cmp(&anchor, &snapshot).is_lt() {- Ordering::Less- } else if excerpt.range.start.cmp(&anchor, &snapshot).is_gt() {- Ordering::Greater- } else {- Ordering::Equal- }- })- .then_with(|| {- if let Some(deleted_hunk_anchor) = region.deleted_hunk_anchor {- deleted_hunk_anchor.cmp(&anchor, &snapshot)- } else {- let point = anchor.to_point(&snapshot);- assert_eq!(region.buffer_id, Some(snapshot.remote_id()));- if region.buffer_range.end < point {- Ordering::Less- } else if region.buffer_range.start > point {- Ordering::Greater- } else {- Ordering::Equal- }- }- })- .is_lt()- });+ let mut now = Instant::now();- let Some(region) = regions.get(ix) else {- return Some(MultiBufferOffset(text.len()));- };+ multibuffer.update(cx, |multibuffer, cx| {+ let transaction_1 = multibuffer.start_transaction_at(now, cx).unwrap();+ multibuffer.edit(+ [+ (Point::new(0, 0)..Point::new(0, 0), "A"),+ (Point::new(1, 0)..Point::new(1, 0), "A"),+ ],+ None,+ cx,+ );+ multibuffer.edit(+ [+ (Point::new(0, 1)..Point::new(0, 1), "B"),+ (Point::new(1, 1)..Point::new(1, 1), "B"),+ ],+ None,+ cx,+ );+ multibuffer.end_transaction_at(now, cx);+ assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");- let offset = if region.buffer_id == Some(snapshot.remote_id()) {- let buffer_offset = anchor.to_offset(&snapshot);- let buffer_range = region.buffer_range.to_offset(&snapshot);- assert!(buffer_offset <= buffer_range.end);- let overshoot = buffer_offset.saturating_sub(buffer_range.start);- region.range.start + overshoot- } else {- region.range.start- };- Some(MultiBufferOffset(offset))- }+ // Verify edited ranges for transaction 1+ assert_eq!(+ multibuffer.edited_ranges_for_transaction(transaction_1, cx),+ &[+ MultiBufferOffset(0)..MultiBufferOffset(2),+ MultiBufferOffset(7)..MultiBufferOffset(9),+ ]+ );- fn anchor_to_buffer_anchor(- &self,- anchor: &Anchor,- cx: &App,- ) -> Option<(text::Anchor, BufferSnapshot, PathKey)> {- let (excerpt, anchor) = match anchor {- Anchor::Min => {- let excerpt = self.excerpts.first()?;- (excerpt, excerpt.range.start)- }- Anchor::Excerpt(excerpt_anchor) => (- self.excerpts.iter().find(|excerpt| {- excerpt.buffer.read(cx).remote_id() == excerpt_anchor.buffer_id()- })?,- excerpt_anchor.text_anchor,- ),- Anchor::Max => {- let excerpt = self.excerpts.last()?;- (excerpt, excerpt.range.end)- }- };+ // Edit buffer 1 through the multibuffer+ now += 2 * group_interval;+ multibuffer.start_transaction_at(now, cx);+ multibuffer.edit(+ [(MultiBufferOffset(2)..MultiBufferOffset(2), "C")],+ None,+ cx,+ );+ multibuffer.end_transaction_at(now, cx);+ assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678");- Some((- anchor,- excerpt.buffer.read(cx).snapshot(),- excerpt.path_key.clone(),- ))- }-}+ // Edit buffer 1 independently+ buffer_1.update(cx, |buffer_1, cx| {+ buffer_1.start_transaction_at(now);+ buffer_1.edit([(3..3, "D")], None, cx);+ buffer_1.end_transaction_at(now, cx);-#[gpui::test(iterations = 100)]-async fn test_random_set_ranges(cx: &mut TestAppContext, mut rng: StdRng) {- let base_text = "a\n".repeat(100);- let buf = cx.update(|cx| cx.new(|cx| Buffer::local(base_text, cx)));- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+ now += 2 * group_interval;+ buffer_1.start_transaction_at(now);+ buffer_1.edit([(4..4, "E")], None, cx);+ buffer_1.end_transaction_at(now, cx);+ });+ assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");- let operations = env::var("OPERATIONS")- .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))- .unwrap_or(10);+ // An undo in the multibuffer undoes the multibuffer transaction+ // and also any individual buffer edits that have occurred since+ // that transaction.+ multibuffer.undo(cx);+ assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");- fn row_ranges(ranges: &Vec<Range<Point>>) -> Vec<Range<u32>> {- ranges- .iter()- .map(|range| range.start.row..range.end.row)- .collect()- }+ multibuffer.undo(cx);+ assert_eq!(multibuffer.read(cx).text(), "1234\n5678");- for _ in 0..operations {- let snapshot = buf.update(cx, |buf, _| buf.snapshot());- let num_ranges = rng.random_range(0..=10);- let max_row = snapshot.max_point().row;- let mut ranges = (0..num_ranges)- .map(|_| {- let start = rng.random_range(0..max_row);- let end = rng.random_range(start + 1..max_row + 1);- Point::row_range(start..end)- })- .collect::<Vec<_>>();- ranges.sort_by_key(|range| range.start);- log::info!("Setting ranges: {:?}", row_ranges(&ranges));- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_excerpts_for_path(- PathKey::for_buffer(&buf, cx),- buf.clone(),- ranges.clone(),- 2,- cx,- )- });+ multibuffer.redo(cx);+ assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");- let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));- let mut last_end = None;- let mut seen_ranges = Vec::default();+ multibuffer.redo(cx);+ assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");- for info in snapshot.excerpts() {- let buffer_snapshot = snapshot- .buffer_for_id(info.context.start.buffer_id)- .unwrap();- let start = info.context.start.to_point(buffer_snapshot);- let end = info.context.end.to_point(buffer_snapshot);- seen_ranges.push(start..end);+ // Undo buffer 2 independently.+ buffer_2.update(cx, |buffer_2, cx| buffer_2.undo(cx));+ assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\n5678");- if let Some(last_end) = last_end.take() {- assert!(- start > last_end,- "multibuffer has out-of-order ranges: {:?}; {:?} <= {:?}",- row_ranges(&seen_ranges),- start,- last_end- )- }+ // An undo in the multibuffer undoes the components of the+ // the last multibuffer transaction that are not already undone.+ multibuffer.undo(cx);+ assert_eq!(multibuffer.read(cx).text(), "AB1234\n5678");- ranges.retain(|range| range.start < start || range.end > end);+ multibuffer.undo(cx);+ assert_eq!(multibuffer.read(cx).text(), "1234\n5678");- last_end = Some(end)- }+ multibuffer.redo(cx);+ assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");- assert!(- ranges.is_empty(),- "multibuffer {:?} did not include all ranges: {:?}",- row_ranges(&seen_ranges),- row_ranges(&ranges)- );- }-}+ buffer_1.update(cx, |buffer_1, cx| buffer_1.redo(cx));+ assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");-#[gpui::test(iterations = 100)]-async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {- let operations = env::var("OPERATIONS")- .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))- .unwrap_or(10);- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));- let mut buffers: Vec<Entity<Buffer>> = Vec::new();- let mut base_texts: HashMap<BufferId, String> = HashMap::default();- let mut reference = ReferenceMultibuffer::default();- let mut anchors = Vec::new();- let mut old_versions = Vec::new();- let mut needs_diff_calculation = false;- let mut inverted_diff_main_buffers: HashMap<BufferId, Entity<BufferDiff>> = HashMap::default();- for _ in 0..operations {- match rng.random_range(0..100) {- 0..=14 if !buffers.is_empty() => {- let buffer = buffers.choose(&mut rng).unwrap();- buffer.update(cx, |buf, cx| {- let edit_count = rng.random_range(1..5);- buf.randomly_edit(&mut rng, edit_count, cx);- log::info!("buffer text:\n{}", buf.text());- needs_diff_calculation = true;- });- cx.update(|cx| reference.diffs_updated(cx));- }- 15..=24 if !reference.excerpts.is_empty() => {- multibuffer.update(cx, |multibuffer, cx| {- let snapshot = multibuffer.snapshot(cx);- let infos = snapshot.excerpts().collect::<Vec<_>>();- let mut excerpts = HashSet::default();- for _ in 0..rng.random_range(0..infos.len()) {- excerpts.extend(infos.choose(&mut rng).cloned());- }+ // Redo stack gets cleared after an edit.+ now += 2 * group_interval;+ multibuffer.start_transaction_at(now, cx);+ multibuffer.edit(+ [(MultiBufferOffset(0)..MultiBufferOffset(0), "X")],+ None,+ cx,+ );+ multibuffer.end_transaction_at(now, cx);+ assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");+ multibuffer.redo(cx);+ assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");+ multibuffer.undo(cx);+ assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");+ multibuffer.undo(cx);+ assert_eq!(multibuffer.read(cx).text(), "1234\n5678");- let line_count = rng.random_range(0..5);+ // Transactions can be grouped manually.+ multibuffer.redo(cx);+ multibuffer.redo(cx);+ assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");+ multibuffer.group_until_transaction(transaction_1, cx);+ multibuffer.undo(cx);+ assert_eq!(multibuffer.read(cx).text(), "1234\n5678");+ multibuffer.redo(cx);+ assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");+ });+}- let excerpt_ixs = excerpts- .iter()- .map(|info| {- reference- .excerpts- .iter()- .position(|e| e.range == info.context)- .unwrap()- })- .collect::<Vec<_>>();- log::info!("Expanding excerpts {excerpt_ixs:?} by {line_count} lines");- multibuffer.expand_excerpts(- excerpts- .iter()- .map(|info| snapshot.anchor_in_excerpt(info.context.end).unwrap()),- line_count,- ExpandExcerptDirection::UpAndDown,- cx,- );+#[gpui::test]+async fn test_enclosing_indent(cx: &mut TestAppContext) {+ async fn enclosing_indent(+ text: &str,+ buffer_row: u32,+ cx: &mut TestAppContext,+ ) -> Option<(Range<u32>, LineIndent)> {+ let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));+ let snapshot = cx.read(|cx| buffer.read(cx).snapshot(cx));+ let (range, indent) = snapshot+ .enclosing_indent(MultiBufferRow(buffer_row))+ .await?;+ Some((range.start.0..range.end.0, indent))+ }- reference.expand_excerpts(&excerpts, line_count, cx);- });- }- 25..=34 if !reference.excerpts.is_empty() => {- let multibuffer =- multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- let offset = multibuffer.clip_offset(- MultiBufferOffset(rng.random_range(0..=multibuffer.len().0)),- Bias::Left,- );- let bias = if rng.random() {- Bias::Left- } else {- Bias::Right- };- log::info!("Creating anchor at {} with bias {:?}", offset.0, bias);- anchors.push(multibuffer.anchor_at(offset, bias));- anchors.sort_by(|a, b| a.cmp(b, &multibuffer));+ assert_eq!(+ enclosing_indent(+ indoc!(+ "+ fn b() {+ if c {+ let d = 2;+ }+ }+ "+ ),+ 1,+ cx,+ )+ .await,+ Some((+ 1..2,+ LineIndent {+ tabs: 0,+ spaces: 4,+ line_blank: false,}- 35..=45 if !reference.excerpts.is_empty() => {- multibuffer.update(cx, |multibuffer, cx| {- let snapshot = multibuffer.snapshot(cx);- let excerpt_ix = rng.random_range(0..reference.excerpts.len());- let excerpt = &reference.excerpts[excerpt_ix];+ ))+ );- // Skip inverted excerpts - hunks can't be collapsed- let buffer_id = excerpt.buffer.read(cx).remote_id();- if reference.inverted_diffs.contains_key(&buffer_id) {- return;+ assert_eq!(+ enclosing_indent(+ indoc!(+ "+ fn b() {+ if c {+ let d = 2;}-- let start = excerpt.range.start;- let end = excerpt.range.end;- let range = snapshot.anchor_in_excerpt(start).unwrap()- ..snapshot.anchor_in_excerpt(end).unwrap();-- log::info!(- "expanding diff hunks in range {:?} (excerpt index {excerpt_ix:?}, buffer id {:?})",- range.to_point(&snapshot),- buffer_id,- );- reference.expand_diff_hunks(excerpt.path_key.clone(), start..end, cx);- multibuffer.expand_diff_hunks(vec![range], cx);- });+ }+ "+ ),+ 2,+ cx,+ )+ .await,+ Some((+ 1..2,+ LineIndent {+ tabs: 0,+ spaces: 4,+ line_blank: false,}- 46..=75 if needs_diff_calculation => {- multibuffer.update(cx, |multibuffer, cx| {- for buffer in multibuffer.all_buffers() {- let snapshot = buffer.read(cx).snapshot();- let buffer_id = snapshot.remote_id();+ ))+ );- if let Some(diff) = multibuffer.diff_for(buffer_id) {- diff.update(cx, |diff, cx| {- log::info!("recalculating diff for buffer {:?}", buffer_id,);- diff.recalculate_diff_sync(&snapshot.text, cx);- });- }+ assert_eq!(+ enclosing_indent(+ indoc!(+ "+ fn b() {+ if c {+ let d = 2;- if let Some(inverted_diff) = inverted_diff_main_buffers.get(&buffer_id) {- inverted_diff.update(cx, |diff, cx| {- log::info!(- "recalculating inverted diff for main buffer {:?}",- buffer_id,- );- diff.recalculate_diff_sync(&snapshot.text, cx);- });- }+ let e = 5;}- reference.diffs_updated(cx);- needs_diff_calculation = false;- });- }- _ => {- // Decide if we're creating a new buffer or reusing an existing one- let create_new_buffer = buffers.is_empty() || rng.random_bool(0.4);-- let (excerpt_buffer, diff, inverted_main_buffer) = if create_new_buffer {- let create_inverted = rng.random_bool(0.3);-- if create_inverted {- let mut main_buffer_text = util::RandomCharIter::new(&mut rng)- .take(256)- .collect::<String>();- let main_buffer = cx.new(|cx| Buffer::local(main_buffer_text.clone(), cx));- text::LineEnding::normalize(&mut main_buffer_text);- let main_buffer_id =- main_buffer.read_with(cx, |buffer, _| buffer.remote_id());- base_texts.insert(main_buffer_id, main_buffer_text.clone());- buffers.push(main_buffer.clone());-- let diff = cx.new(|cx| {- BufferDiff::new_with_base_text(- &main_buffer_text,- &main_buffer.read(cx).text_snapshot(),- cx,- )- });+ }+ "+ ),+ 3,+ cx,+ )+ .await,+ Some((+ 1..4,+ LineIndent {+ tabs: 0,+ spaces: 4,+ line_blank: false,+ }+ ))+ );+}- let base_text_buffer =- diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());+#[gpui::test]+async fn test_summaries_for_anchors(cx: &mut TestAppContext) {+ let base_text_1 = indoc!(+ "+ bar+ "+ );+ let text_1 = indoc!(+ "+ BAR+ "+ );+ let base_text_2 = indoc!(+ "+ foo+ "+ );+ let text_2 = indoc!(+ "+ FOO+ "+ );- // Track for recalculation when main buffer is edited- inverted_diff_main_buffers.insert(main_buffer_id, diff.clone());+ let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));+ let buffer_2 = cx.new(|cx| Buffer::local(text_2, cx));+ let diff_1 = cx.new(|cx| {+ BufferDiff::new_with_base_text(base_text_1, &buffer_1.read(cx).text_snapshot(), cx)+ });+ let diff_2 = cx.new(|cx| {+ BufferDiff::new_with_base_text(base_text_2, &buffer_2.read(cx).text_snapshot(), cx)+ });+ cx.run_until_parked();- (base_text_buffer, diff, Some(main_buffer))- } else {- let mut base_text = util::RandomCharIter::new(&mut rng)- .take(256)- .collect::<String>();+ let multibuffer = cx.new(|cx| {+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);+ multibuffer.set_all_diff_hunks_expanded(cx);+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer_1.clone(),+ [Point::zero()..buffer_1.read(cx).max_point()],+ 0,+ cx,+ );+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(1),+ buffer_2.clone(),+ [Point::zero()..buffer_2.read(cx).max_point()],+ 0,+ cx,+ );+ multibuffer.add_diff(diff_1.clone(), cx);+ multibuffer.add_diff(diff_2.clone(), cx);+ multibuffer+ });- let buffer_handle = cx.new(|cx| Buffer::local(base_text.clone(), cx));- text::LineEnding::normalize(&mut base_text);- let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());- base_texts.insert(buffer_id, base_text.clone());- buffers.push(buffer_handle.clone());+ let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {+ (multibuffer.snapshot(cx), multibuffer.subscribe())+ });- let diff = cx.new(|cx| {- BufferDiff::new_with_base_text(- &base_text,- &buffer_handle.read(cx).text_snapshot(),- cx,- )- });+ assert_new_snapshot(+ &multibuffer,+ &mut snapshot,+ &mut subscription,+ cx,+ indoc!(+ "+ - bar+ + BAR- (buffer_handle, diff, None)- }- } else {- // Reuse an existing buffer- let buffer_handle = buffers.choose(&mut rng).unwrap().clone();- let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());+ - foo+ + FOO+ "+ ),+ );- if let Some(diff) = inverted_diff_main_buffers.get(&buffer_id) {- let base_text_buffer =- diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());- (base_text_buffer, diff.clone(), Some(buffer_handle))- } else {- // Get existing diff or create new one for regular buffer- let diff = multibuffer- .read_with(cx, |mb, _| mb.diff_for(buffer_id))- .unwrap_or_else(|| {- let base_text = base_texts.get(&buffer_id).unwrap();- cx.new(|cx| {- BufferDiff::new_with_base_text(- base_text,- &buffer_handle.read(cx).text_snapshot(),- cx,- )- })- });- (buffer_handle, diff, None)- }- };+ let anchor_1 = multibuffer.read_with(cx, |multibuffer, cx| {+ multibuffer+ .snapshot(cx)+ .anchor_in_excerpt(text::Anchor::min_for_buffer(buffer_1.read(cx).remote_id()))+ .unwrap()+ });+ let point_1 = snapshot.summaries_for_anchors::<Point, _>([&anchor_1])[0];+ assert_eq!(point_1, Point::new(0, 0));- let excerpt_buffer_snapshot =- excerpt_buffer.read_with(cx, |excerpt_buffer, _| excerpt_buffer.snapshot());- let mut ranges = reference- .excerpts- .iter()- .filter(|excerpt| excerpt.buffer == excerpt_buffer)- .map(|excerpt| excerpt.range.to_point(&excerpt_buffer_snapshot))- .collect::<Vec<_>>();- mutate_excerpt_ranges(&mut rng, &mut ranges, &excerpt_buffer_snapshot, 1);- let ranges = ranges- .iter()- .cloned()- .map(ExcerptRange::new)- .collect::<Vec<_>>();- let path = cx.update(|cx| PathKey::for_buffer(&excerpt_buffer, cx));- let path_key_index = multibuffer.update(cx, |multibuffer, _| {- multibuffer.get_or_create_path_key_index(&path)- });+ let anchor_2 = multibuffer.read_with(cx, |multibuffer, cx| {+ multibuffer+ .snapshot(cx)+ .anchor_in_excerpt(text::Anchor::min_for_buffer(buffer_2.read(cx).remote_id()))+ .unwrap()+ });+ let point_2 = snapshot.summaries_for_anchors::<Point, _>([&anchor_2])[0];+ assert_eq!(point_2, Point::new(3, 0));+}- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_excerpt_ranges_for_path(- path.clone(),- excerpt_buffer.clone(),- &excerpt_buffer_snapshot,- ranges.clone(),- cx,- )- });+#[gpui::test]+async fn test_trailing_deletion_without_newline(cx: &mut TestAppContext) {+ let base_text_1 = "one\ntwo".to_owned();+ let text_1 = "one\n".to_owned();- cx.update(|cx| {- reference.set_excerpts(- path,- path_key_index,- excerpt_buffer.clone(),- &excerpt_buffer_snapshot,- ranges,- cx,- )- });+ let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));+ let diff_1 = cx.new(|cx| {+ BufferDiff::new_with_base_text(&base_text_1, &buffer_1.read(cx).text_snapshot(), cx)+ });+ cx.run_until_parked();- let excerpt_buffer_id =- excerpt_buffer.read_with(cx, |buffer, _| buffer.remote_id());- multibuffer.update(cx, |multibuffer, cx| {- if multibuffer.diff_for(excerpt_buffer_id).is_none() {- if let Some(main_buffer) = inverted_main_buffer {- reference.add_inverted_diff(diff.clone(), main_buffer.clone(), cx);- multibuffer.add_inverted_diff(diff, main_buffer, cx);- } else {- reference.add_diff(diff.clone(), cx);- multibuffer.add_diff(diff, cx);- }- }- });- }- }+ let multibuffer = cx.new(|cx| {+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer_1.clone(),+ [Point::zero()..buffer_1.read(cx).max_point()],+ 0,+ cx,+ );+ multibuffer.add_diff(diff_1.clone(), cx);+ multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);+ multibuffer+ });- if rng.random_bool(0.3) {- multibuffer.update(cx, |multibuffer, cx| {- old_versions.push((multibuffer.snapshot(cx), multibuffer.subscribe()));- })- }+ let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {+ (multibuffer.snapshot(cx), multibuffer.subscribe())+ });- multibuffer.read_with(cx, |multibuffer, cx| {- check_multibuffer(multibuffer, &reference, &anchors, cx, &mut rng);- });- }- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- for (old_snapshot, subscription) in old_versions {- check_multibuffer_edits(&snapshot, &old_snapshot, subscription);- }-}+ assert_new_snapshot(+ &multibuffer,+ &mut snapshot,+ &mut subscription,+ cx,+ indoc!(+ "+ one+ - two+ "+ ),+ );-fn mutate_excerpt_ranges(- rng: &mut StdRng,- existing_ranges: &mut Vec<Range<Point>>,- buffer: &BufferSnapshot,- operations: u32,-) {- let mut ranges_to_add = Vec::new();+ assert_eq!(snapshot.max_point(), Point::new(2, 0));+ assert_eq!(snapshot.len().0, 8);- for _ in 0..operations {- match rng.random_range(0..5) {- 0..=1 if !existing_ranges.is_empty() => {- let index = rng.random_range(0..existing_ranges.len());- log::info!("Removing excerpt at index {index}");- existing_ranges.remove(index);- }- _ => {- let end_row = rng.random_range(0..=buffer.max_point().row);- let start_row = rng.random_range(0..=end_row);- let end_col = buffer.line_len(end_row);- log::info!(- "Inserting excerpt for buffer {:?}, row range {:?}",- buffer.remote_id(),- start_row..end_row- );- ranges_to_add.push(Point::new(start_row, 0)..Point::new(end_row, end_col));- }- }- }+ assert_eq!(+ snapshot+ .dimensions_from_points::<Point>([Point::new(2, 0)])+ .collect::<Vec<_>>(),+ vec![Point::new(2, 0)]+ );- existing_ranges.extend(ranges_to_add);- existing_ranges.sort_by_key(|r| r.start);-}+ let (_, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();+ assert_eq!(translated_offset.0, "one\n".len());+ let (_, translated_point) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();+ assert_eq!(translated_point, Point::new(1, 0));-fn check_multibuffer(- multibuffer: &MultiBuffer,- reference: &ReferenceMultibuffer,- anchors: &[Anchor],- cx: &App,- rng: &mut StdRng,-) {- let snapshot = multibuffer.snapshot(cx);- let actual_text = snapshot.text();- let actual_boundary_rows = snapshot- .excerpt_boundaries_in_range(MultiBufferOffset(0)..)- .map(|b| b.row)- .collect::<HashSet<_>>();- let actual_row_infos = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();+ // The same, for an excerpt that's not at the end of the multibuffer.- let anchors_to_check = anchors- .iter()- .filter_map(|anchor| {- snapshot- .anchor_to_buffer_anchor(*anchor)- .map(|(anchor, _)| anchor)- })- // Intentionally mix in some anchors that are (in general) not contained in any excerpt- .chain(- reference- .excerpts- .iter()- .map(|excerpt| excerpt.buffer.read(cx).remote_id())- .dedup()- .flat_map(|buffer_id| {- [- text::Anchor::min_for_buffer(buffer_id),- text::Anchor::max_for_buffer(buffer_id),- ]- }),- )- .map(|anchor| snapshot.anchor_in_buffer(anchor).unwrap())- .collect::<Vec<_>>();+ let text_2 = "foo\n".to_owned();+ let buffer_2 = cx.new(|cx| Buffer::local(&text_2, cx));+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpt_ranges_for_path(+ PathKey::sorted(1),+ buffer_2.clone(),+ &buffer_2.read(cx).snapshot(),+ vec![ExcerptRange::new(Point::new(0, 0)..Point::new(1, 0))],+ cx,+ );+ });- let (expected_text, expected_row_infos, expected_boundary_rows, _) =- reference.expected_content(cx);- let expected_anchor_offsets = anchors_to_check- .iter()- .map(|anchor| reference.anchor_to_offset(anchor, cx).unwrap())- .collect::<Vec<_>>();+ assert_new_snapshot(+ &multibuffer,+ &mut snapshot,+ &mut subscription,+ cx,+ indoc!(+ "+ one+ - two- let has_diff = actual_row_infos- .iter()- .any(|info| info.diff_status.is_some())- || expected_row_infos- .iter()- .any(|info| info.diff_status.is_some());- let actual_diff = format_diff(- &actual_text,- &actual_row_infos,- &actual_boundary_rows,- Some(has_diff),- );- let expected_diff = format_diff(- &expected_text,- &expected_row_infos,- &expected_boundary_rows,- Some(has_diff),+ foo+ "+ ),);- log::info!("Multibuffer content:\n{}", actual_diff);-assert_eq!(- actual_row_infos.len(),- actual_text.split('\n').count(),- "line count: {}",- actual_text.split('\n').count()+ snapshot+ .dimensions_from_points::<Point>([Point::new(2, 0)])+ .collect::<Vec<_>>(),+ vec![Point::new(2, 0)]);- pretty_assertions::assert_eq!(actual_diff, expected_diff);- pretty_assertions::assert_eq!(actual_text, expected_text);- pretty_assertions::assert_eq!(actual_row_infos, expected_row_infos);- for _ in 0..5 {- let start_row = rng.random_range(0..=expected_row_infos.len());- assert_eq!(- snapshot- .row_infos(MultiBufferRow(start_row as u32))- .collect::<Vec<_>>(),- &expected_row_infos[start_row..],- "buffer_rows({})",- start_row- );- }+ let buffer_1_id = buffer_1.read_with(cx, |buffer_1, _| buffer_1.remote_id());+ let (buffer, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();+ assert_eq!(buffer.remote_id(), buffer_1_id);+ assert_eq!(translated_offset.0, "one\n".len());+ let (buffer, translated_point) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();+ assert_eq!(buffer.remote_id(), buffer_1_id);+ assert_eq!(translated_point, Point::new(1, 0));+}- assert_eq!(- snapshot.widest_line_number(),- expected_row_infos- .into_iter()- .filter_map(|info| {- // For inverted diffs, deleted rows are visible and should be counted.- // Only filter out deleted rows that are NOT from inverted diffs.- let is_inverted_diff = info- .buffer_id- .is_some_and(|id| reference.inverted_diffs.contains_key(&id));- if info.diff_status.is_some_and(|status| status.is_deleted()) && !is_inverted_diff {- None- } else {- info.buffer_row- }- })- .max()- .unwrap()- + 1+#[gpui::test]+async fn test_singleton_with_inverted_diff(cx: &mut TestAppContext) {+ let text = indoc!(+ "+ ZERO+ one+ TWO+ three+ six+ "+ );+ let base_text = indoc!(+ "+ one+ two+ three+ four+ five+ six+ ");- for i in 0..snapshot.len().0 {- let (_, excerpt_range) = snapshot- .excerpt_containing(MultiBufferOffset(i)..MultiBufferOffset(i))- .unwrap();- reference- .excerpts- .iter()- .find(|reference_excerpt| reference_excerpt.range == excerpt_range.context)- .expect("corresponding excerpt should exist in reference multibuffer");- }- assert_consistent_line_numbers(&snapshot);- assert_position_translation(&snapshot);+ let buffer = cx.new(|cx| Buffer::local(text, cx));+ let diff = cx+ .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));+ cx.run_until_parked();- for (row, line) in expected_text.split('\n').enumerate() {- assert_eq!(- snapshot.line_len(MultiBufferRow(row as u32)),- line.len() as u32,- "line_len({}).",- row- );- }+ let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());- let text_rope = Rope::from(expected_text.as_str());- for _ in 0..10 {- let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);- let start_ix = text_rope.clip_offset(rng.random_range(0..=end_ix), Bias::Left);+ let multibuffer = cx.new(|cx| {+ let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);+ multibuffer.set_all_diff_hunks_expanded(cx);+ multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);+ multibuffer+ });- let text_for_range = snapshot- .text_for_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))- .collect::<String>();- assert_eq!(- text_for_range,- &expected_text[start_ix..end_ix],- "incorrect text for range {:?}",- start_ix..end_ix- );+ let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {+ (multibuffer.snapshot(cx), multibuffer.subscribe())+ });- let expected_summary =- MBTextSummary::from(TextSummary::from(&expected_text[start_ix..end_ix]));- assert_eq!(- snapshot.text_summary_for_range::<MBTextSummary, _>(- MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix)- ),- expected_summary,- "incorrect summary for range {:?}",- start_ix..end_ix- );- }+ assert_eq!(snapshot.text(), base_text);+ assert_new_snapshot(+ &multibuffer,+ &mut snapshot,+ &mut subscription,+ cx,+ indoc!(+ "+ one+ - two+ three+ - four+ - five+ six+ "+ ),+ );- // Anchor resolution- let summaries = snapshot.summaries_for_anchors::<MultiBufferOffset, _>(anchors);- assert_eq!(anchors.len(), summaries.len());- for (anchor, resolved_offset) in anchors.iter().zip(summaries) {- assert!(resolved_offset <= snapshot.len());- assert_eq!(- snapshot.summary_for_anchor::<MultiBufferOffset>(anchor),- resolved_offset,- "anchor: {:?}",- anchor+ buffer.update(cx, |buffer, cx| {+ buffer.edit_via_marked_text(+ indoc!(+ "+ ZERO+ one+ «<inserted>»W«O+ T»hree+ six+ "+ ),+ None,+ 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_snapshot,+ &base_text_snapshot,+ Some(Arc::from(base_text)),+ cx,+ )+ })+ .await;+ diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));+ cx.run_until_parked();- let actual_anchor_offsets = anchors_to_check- .into_iter()- .map(|anchor| anchor.to_offset(&snapshot))- .collect::<Vec<_>>();- assert_eq!(- actual_anchor_offsets, expected_anchor_offsets,- "buffer anchor resolves to wrong offset"+ assert_new_snapshot(+ &multibuffer,+ &mut snapshot,+ &mut subscription,+ cx,+ indoc! {+ "+ one+ - two+ - three+ - four+ - five+ six+ "+ },);- for _ in 0..10 {- let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);- assert_eq!(- snapshot- .reversed_chars_at(MultiBufferOffset(end_ix))- .collect::<String>(),- expected_text[..end_ix].chars().rev().collect::<String>(),- );- }+ buffer.update(cx, |buffer, cx| {+ 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_snapshot,+ &base_text_snapshot,+ Some(Arc::from(base_text)),+ cx,+ )+ })+ .await;+ diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));+ cx.run_until_parked();- for _ in 0..10 {- let end_ix = rng.random_range(0..=text_rope.len());- let end_ix = text_rope.floor_char_boundary(end_ix);- let start_ix = rng.random_range(0..=end_ix);- let start_ix = text_rope.floor_char_boundary(start_ix);- assert_eq!(- snapshot- .bytes_in_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))- .flatten()- .copied()- .collect::<Vec<_>>(),- expected_text.as_bytes()[start_ix..end_ix].to_vec(),- "bytes_in_range({:?})",- start_ix..end_ix,- );- }-}+ assert_new_snapshot(+ &multibuffer,+ &mut snapshot,+ &mut subscription,+ cx,+ indoc! {+ "+ - one+ - two+ - three+ - four+ - five+ - six+ "+ },+ );-fn check_multibuffer_edits(- snapshot: &MultiBufferSnapshot,- old_snapshot: &MultiBufferSnapshot,- subscription: Subscription<MultiBufferOffset>,-) {- let edits = subscription.consume().into_inner();+ diff.update(cx, |diff, cx| {+ diff.set_base_text(+ Some("new base\n".into()),+ buffer.read(cx).text_snapshot(),+ cx,+ )+ })+ .await;+ cx.run_until_parked();- log::info!(- "applying subscription edits to old text: {:?}: {:#?}",- old_snapshot.text(),- edits,+ assert_new_snapshot(+ &multibuffer,+ &mut snapshot,+ &mut subscription,+ cx,+ indoc! {"+ - new base+ "},);-- let mut text = old_snapshot.text();- for edit in edits {- let new_text: String = snapshot- .text_for_range(edit.new.start..edit.new.end)- .collect();- text.replace_range(- (edit.new.start.0..edit.new.start.0 + (edit.old.end.0 - edit.old.start.0)).clone(),- &new_text,- );- pretty_assertions::assert_eq!(- &text[0..edit.new.end.0],- snapshot- .text_for_range(MultiBufferOffset(0)..edit.new.end)- .collect::<String>()- );- }- pretty_assertions::assert_eq!(text, snapshot.text());}#[gpui::test]-fn test_history(cx: &mut App) {- let test_settings = SettingsStore::test(cx);- cx.set_global(test_settings);+async fn test_inverted_diff_base_text_change(cx: &mut TestAppContext) {+ let base_text = "aaa\nbbb\nccc\n";+ let text = "ddd\n";+ let buffer = cx.new(|cx| Buffer::local(text, cx));+ let diff = cx+ .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));+ cx.run_until_parked();- let group_interval: Duration = Duration::from_millis(1);- let buffer_1 = cx.new(|cx| {- let mut buf = Buffer::local("1234", cx);- buf.set_group_interval(group_interval);- buf- });- let buffer_2 = cx.new(|cx| {- let mut buf = Buffer::local("5678", cx);- buf.set_group_interval(group_interval);- buf- });- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));- multibuffer.update(cx, |this, cx| {- this.set_group_interval(group_interval, cx);- });- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_1.clone(),- [Point::zero()..buffer_1.read(cx).max_point()],- 0,- cx,- );- multibuffer.set_excerpts_for_path(- PathKey::sorted(1),- buffer_2.clone(),- [Point::zero()..buffer_2.read(cx).max_point()],- 0,- cx,- );+ let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());++ let multibuffer = cx.new(|cx| {+ let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);+ multibuffer.set_all_diff_hunks_expanded(cx);+ multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);+ multibuffer});- let mut now = Instant::now();+ let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {+ (multibuffer.snapshot(cx), multibuffer.subscribe())+ });- multibuffer.update(cx, |multibuffer, cx| {- let transaction_1 = multibuffer.start_transaction_at(now, cx).unwrap();- multibuffer.edit(- [- (Point::new(0, 0)..Point::new(0, 0), "A"),- (Point::new(1, 0)..Point::new(1, 0), "A"),- ],- None,- cx,- );- multibuffer.edit(- [- (Point::new(0, 1)..Point::new(0, 1), "B"),- (Point::new(1, 1)..Point::new(1, 1), "B"),- ],- None,- cx,- );- multibuffer.end_transaction_at(now, cx);- assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");+ assert_eq!(snapshot.text(), base_text);+ assert_new_snapshot(+ &multibuffer,+ &mut snapshot,+ &mut subscription,+ cx,+ indoc!(+ "+ - aaa+ - bbb+ - ccc+ "+ ),+ );- // Verify edited ranges for transaction 1- assert_eq!(- multibuffer.edited_ranges_for_transaction(transaction_1, cx),- &[- MultiBufferOffset(0)..MultiBufferOffset(2),- MultiBufferOffset(7)..MultiBufferOffset(9),- ]- );+ diff.update(cx, |diff, cx| {+ diff.set_base_text(Some("ddd\n".into()), buffer.read(cx).text_snapshot(), cx)+ })+ .await;- // Edit buffer 1 through the multibuffer- now += 2 * group_interval;- multibuffer.start_transaction_at(now, cx);- multibuffer.edit(- [(MultiBufferOffset(2)..MultiBufferOffset(2), "C")],- None,- cx,- );- multibuffer.end_transaction_at(now, cx);- assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678");+ let _hunks: Vec<_> = multibuffer+ .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))+ .diff_hunks()+ .collect();+}- // Edit buffer 1 independently- buffer_1.update(cx, |buffer_1, cx| {- buffer_1.start_transaction_at(now);- buffer_1.edit([(3..3, "D")], None, cx);- buffer_1.end_transaction_at(now, cx);+#[gpui::test]+async fn test_inverted_diff_secondary_version_mismatch(cx: &mut TestAppContext) {+ let base_text = "one\ntwo\nthree\nfour\nfive\n";+ let index_text = "one\nTWO\nthree\nfour\nfive\n";+ let buffer_text = "one\nTWO\nthree\nFOUR\nfive\n";- now += 2 * group_interval;- buffer_1.start_transaction_at(now);- buffer_1.edit([(4..4, "E")], None, cx);- buffer_1.end_transaction_at(now, cx);- });- assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");+ let buffer = cx.new(|cx| Buffer::local(buffer_text, cx));- // An undo in the multibuffer undoes the multibuffer transaction- // and also any individual buffer edits that have occurred since- // that transaction.- multibuffer.undo(cx);- assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");+ let unstaged_diff = cx+ .new(|cx| BufferDiff::new_with_base_text(index_text, &buffer.read(cx).text_snapshot(), cx));+ cx.run_until_parked();- multibuffer.undo(cx);- assert_eq!(multibuffer.read(cx).text(), "1234\n5678");+ let uncommitted_diff = cx.new(|cx| {+ let mut diff =+ BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx);+ diff.set_secondary_diff(unstaged_diff.clone());+ diff+ });+ cx.run_until_parked();- multibuffer.redo(cx);- assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");+ buffer.update(cx, |buffer, cx| {+ buffer.edit([(0..0, "ZERO\n")], None, cx);+ });- multibuffer.redo(cx);- assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");+ 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_snapshot,+ &base_text_snapshot,+ Some(Arc::from(index_text)),+ cx,+ )+ })+ .await;+ unstaged_diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));- // Undo buffer 2 independently.- buffer_2.update(cx, |buffer_2, cx| buffer_2.undo(cx));- assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\n5678");+ let base_text_buffer =+ uncommitted_diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());- // An undo in the multibuffer undoes the components of the- // the last multibuffer transaction that are not already undone.- multibuffer.undo(cx);- assert_eq!(multibuffer.read(cx).text(), "AB1234\n5678");+ let multibuffer = cx.new(|cx| {+ let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);+ multibuffer.set_all_diff_hunks_expanded(cx);+ multibuffer.add_inverted_diff(uncommitted_diff.clone(), buffer.clone(), cx);+ multibuffer+ });- multibuffer.undo(cx);- assert_eq!(multibuffer.read(cx).text(), "1234\n5678");+ let _hunks: Vec<_> = multibuffer+ .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))+ .diff_hunks()+ .collect();+}- multibuffer.redo(cx);- assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");+#[gpui::test]+fn test_new_empty_buffer_uses_untitled_title(cx: &mut App) {+ let buffer = cx.new(|cx| Buffer::local("", cx));+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));- buffer_1.update(cx, |buffer_1, cx| buffer_1.redo(cx));- assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");+ assert_eq!(multibuffer.read(cx).title(cx), "untitled");+}- // Redo stack gets cleared after an edit.- now += 2 * group_interval;- multibuffer.start_transaction_at(now, cx);- multibuffer.edit(- [(MultiBufferOffset(0)..MultiBufferOffset(0), "X")],- None,- cx,- );- multibuffer.end_transaction_at(now, cx);- assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");- multibuffer.redo(cx);- assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");- multibuffer.undo(cx);- assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");- multibuffer.undo(cx);- assert_eq!(multibuffer.read(cx).text(), "1234\n5678");+#[gpui::test]+fn test_new_empty_buffer_uses_untitled_title_when_only_contains_whitespace(cx: &mut App) {+ let buffer = cx.new(|cx| Buffer::local("\n ", cx));+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));- // Transactions can be grouped manually.- multibuffer.redo(cx);- multibuffer.redo(cx);- assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");- multibuffer.group_until_transaction(transaction_1, cx);- multibuffer.undo(cx);- assert_eq!(multibuffer.read(cx).text(), "1234\n5678");- multibuffer.redo(cx);- assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");- });+ assert_eq!(multibuffer.read(cx).title(cx), "untitled");}#[gpui::test]-async fn test_enclosing_indent(cx: &mut TestAppContext) {- async fn enclosing_indent(- text: &str,- buffer_row: u32,- cx: &mut TestAppContext,- ) -> Option<(Range<u32>, LineIndent)> {- let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));- let snapshot = cx.read(|cx| buffer.read(cx).snapshot(cx));- let (range, indent) = snapshot- .enclosing_indent(MultiBufferRow(buffer_row))- .await?;- Some((range.start.0..range.end.0, indent))- }+fn test_new_empty_buffer_takes_first_line_for_title(cx: &mut App) {+ let buffer = cx.new(|cx| Buffer::local("Hello World\nSecond line", cx));+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));- assert_eq!(- enclosing_indent(- indoc!(- "- fn b() {- if c {- let d = 2;- }- }- "- ),- 1,- cx,- )- .await,- Some((- 1..2,- LineIndent {- tabs: 0,- spaces: 4,- line_blank: false,- }- ))- );+ assert_eq!(multibuffer.read(cx).title(cx), "Hello World");+}- assert_eq!(- enclosing_indent(- indoc!(- "- fn b() {- if c {- let d = 2;- }- }- "- ),- 2,- cx,- )- .await,- Some((- 1..2,- LineIndent {- tabs: 0,- spaces: 4,- line_blank: false,- }- ))- );+#[gpui::test]+fn test_new_empty_buffer_takes_trimmed_first_line_for_title(cx: &mut App) {+ let buffer = cx.new(|cx| Buffer::local("\nHello, World ", cx));+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));- assert_eq!(- enclosing_indent(- indoc!(- "- fn b() {- if c {- let d = 2;-- let e = 5;- }- }- "- ),- 3,- cx,- )- .await,- Some((- 1..4,- LineIndent {- tabs: 0,- spaces: 4,- line_blank: false,- }- ))- );-}+ assert_eq!(multibuffer.read(cx).title(cx), "Hello, World");+}#[gpui::test]-async fn test_summaries_for_anchors(cx: &mut TestAppContext) {- let base_text_1 = indoc!(- "- bar- "- );- let text_1 = indoc!(- "- BAR- "- );- let base_text_2 = indoc!(- "- foo- "- );- let text_2 = indoc!(- "- FOO- "- );-- let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));- let buffer_2 = cx.new(|cx| Buffer::local(text_2, cx));- let diff_1 = cx.new(|cx| {- BufferDiff::new_with_base_text(base_text_1, &buffer_1.read(cx).text_snapshot(), cx)- });- let diff_2 = cx.new(|cx| {- BufferDiff::new_with_base_text(base_text_2, &buffer_2.read(cx).text_snapshot(), cx)- });- cx.run_until_parked();-- let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);- multibuffer.set_all_diff_hunks_expanded(cx);- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_1.clone(),- [Point::zero()..buffer_1.read(cx).max_point()],- 0,- cx,- );- multibuffer.set_excerpts_for_path(- PathKey::sorted(1),- buffer_2.clone(),- [Point::zero()..buffer_2.read(cx).max_point()],- 0,- cx,- );- multibuffer.add_diff(diff_1.clone(), cx);- multibuffer.add_diff(diff_2.clone(), cx);- multibuffer- });-- let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {- (multibuffer.snapshot(cx), multibuffer.subscribe())- });-- assert_new_snapshot(- &multibuffer,- &mut snapshot,- &mut subscription,- cx,- indoc!(- "- - bar- + BAR-- - foo- + FOO- "- ),- );-- let anchor_1 = multibuffer.read_with(cx, |multibuffer, cx| {- multibuffer- .snapshot(cx)- .anchor_in_excerpt(text::Anchor::min_for_buffer(buffer_1.read(cx).remote_id()))- .unwrap()- });- let point_1 = snapshot.summaries_for_anchors::<Point, _>([&anchor_1])[0];- assert_eq!(point_1, Point::new(0, 0));+fn test_new_empty_buffer_uses_truncated_first_line_for_title(cx: &mut App) {+ let title = "aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeee";+ let title_after = "aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd";+ let buffer = cx.new(|cx| Buffer::local(title, cx));+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));- let anchor_2 = multibuffer.read_with(cx, |multibuffer, cx| {- multibuffer- .snapshot(cx)- .anchor_in_excerpt(text::Anchor::min_for_buffer(buffer_2.read(cx).remote_id()))- .unwrap()- });- let point_2 = snapshot.summaries_for_anchors::<Point, _>([&anchor_2])[0];- assert_eq!(point_2, Point::new(3, 0));+ assert_eq!(multibuffer.read(cx).title(cx), title_after);}#[gpui::test]-async fn test_trailing_deletion_without_newline(cx: &mut TestAppContext) {- let base_text_1 = "one\ntwo".to_owned();- let text_1 = "one\n".to_owned();+fn test_new_empty_buffer_uses_truncated_first_line_for_title_after_merging_adjacent_spaces(+ cx: &mut App,+) {+ let title = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddddeeeeeeeeee";+ let title_after = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddd";+ let buffer = cx.new(|cx| Buffer::local(title, cx));+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));- let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));- let diff_1 = cx.new(|cx| {- BufferDiff::new_with_base_text(&base_text_1, &buffer_1.read(cx).text_snapshot(), cx)- });- cx.run_until_parked();+ assert_eq!(multibuffer.read(cx).title(cx), title_after);+}- let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_1.clone(),- [Point::zero()..buffer_1.read(cx).max_point()],- 0,- cx,- );- multibuffer.add_diff(diff_1.clone(), cx);- multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);- multibuffer- });+#[gpui::test]+fn test_new_empty_buffers_title_can_be_set(cx: &mut App) {+ let buffer = cx.new(|cx| Buffer::local("Hello World", cx));+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));+ assert_eq!(multibuffer.read(cx).title(cx), "Hello World");- let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {- (multibuffer.snapshot(cx), multibuffer.subscribe())+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_title("Hey".into(), cx)});+ assert_eq!(multibuffer.read(cx).title(cx), "Hey");+}- assert_new_snapshot(- &multibuffer,- &mut snapshot,- &mut subscription,- cx,- indoc!(- "- one- - two- "- ),- );+#[gpui::test(iterations = 100)]+fn test_random_chunk_bitmaps(cx: &mut App, mut rng: StdRng) {+ let multibuffer = if rng.random() {+ let len = rng.random_range(0..10000);+ let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();+ let buffer = cx.new(|cx| Buffer::local(text, cx));+ cx.new(|cx| MultiBuffer::singleton(buffer, cx))+ } else {+ MultiBuffer::build_random(&mut rng, cx)+ };- assert_eq!(snapshot.max_point(), Point::new(2, 0));- assert_eq!(snapshot.len().0, 8);+ let snapshot = multibuffer.read(cx).snapshot(cx);- assert_eq!(- snapshot- .dimensions_from_points::<Point>([Point::new(2, 0)])- .collect::<Vec<_>>(),- vec![Point::new(2, 0)]+ let chunks = snapshot.chunks(+ MultiBufferOffset(0)..snapshot.len(),+ LanguageAwareStyling {+ tree_sitter: false,+ diagnostics: false,+ },);- let (_, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();- assert_eq!(translated_offset.0, "one\n".len());- let (_, translated_point) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();- assert_eq!(translated_point, Point::new(1, 0));+ for chunk in chunks {+ let chunk_text = chunk.text;+ let chars_bitmap = chunk.chars;+ let tabs_bitmap = chunk.tabs;- // The same, for an excerpt that's not at the end of the multibuffer.+ if chunk_text.is_empty() {+ assert_eq!(+ chars_bitmap, 0,+ "Empty chunk should have empty chars bitmap"+ );+ assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");+ continue;+ }- let text_2 = "foo\n".to_owned();- let buffer_2 = cx.new(|cx| Buffer::local(&text_2, cx));- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_excerpt_ranges_for_path(- PathKey::sorted(1),- buffer_2.clone(),- &buffer_2.read(cx).snapshot(),- vec![ExcerptRange::new(Point::new(0, 0)..Point::new(1, 0))],- cx,+ assert!(+ chunk_text.len() <= 128,+ "Chunk text length {} exceeds 128 bytes",+ chunk_text.len());- });- assert_new_snapshot(- &multibuffer,- &mut snapshot,- &mut subscription,- cx,- indoc!(- "- one- - two+ // Verify chars bitmap+ let char_indices = chunk_text+ .char_indices()+ .map(|(i, _)| i)+ .collect::<Vec<_>>();- foo- "- ),- );+ for byte_idx in 0..chunk_text.len() {+ let should_have_bit = char_indices.contains(&byte_idx);+ let has_bit = chars_bitmap & (1 << byte_idx) != 0;- assert_eq!(- snapshot- .dimensions_from_points::<Point>([Point::new(2, 0)])- .collect::<Vec<_>>(),- vec![Point::new(2, 0)]- );+ if has_bit != should_have_bit {+ eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());+ eprintln!("Char indices: {:?}", char_indices);+ eprintln!("Chars bitmap: {:#b}", chars_bitmap);+ }- let buffer_1_id = buffer_1.read_with(cx, |buffer_1, _| buffer_1.remote_id());- let (buffer, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();- assert_eq!(buffer.remote_id(), buffer_1_id);- assert_eq!(translated_offset.0, "one\n".len());- let (buffer, translated_point) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();- assert_eq!(buffer.remote_id(), buffer_1_id);- assert_eq!(translated_point, Point::new(1, 0));-}+ assert_eq!(+ has_bit, should_have_bit,+ "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",+ byte_idx, chunk_text, should_have_bit, has_bit+ );+ }-fn format_diff(- text: &str,- row_infos: &Vec<RowInfo>,- boundary_rows: &HashSet<MultiBufferRow>,- has_diff: Option<bool>,-) -> String {- let has_diff =- has_diff.unwrap_or_else(|| row_infos.iter().any(|info| info.diff_status.is_some()));- text.split('\n')- .enumerate()- .zip(row_infos)- .map(|((ix, line), info)| {- let marker = match info.diff_status.map(|status| status.kind) {- Some(DiffHunkStatusKind::Added) => "+ ",- Some(DiffHunkStatusKind::Deleted) => "- ",- Some(DiffHunkStatusKind::Modified) => unreachable!(),- None => {- if has_diff && !line.is_empty() {- " "- } else {- ""- }- }- };- let boundary_row = if boundary_rows.contains(&MultiBufferRow(ix as u32)) {- if has_diff {- " ----------\n"- } else {- "---------\n"- }- } else {- ""- };- let expand = info- .expand_info- .as_ref()- .map(|expand_info| match expand_info.direction {- ExpandExcerptDirection::Up => " [↑]",- ExpandExcerptDirection::Down => " [↓]",- ExpandExcerptDirection::UpAndDown => " [↕]",- })- .unwrap_or_default();+ for (byte_idx, byte) in chunk_text.bytes().enumerate() {+ let is_tab = byte == b'\t';+ let has_bit = tabs_bitmap & (1 << byte_idx) != 0;- format!("{boundary_row}{marker}{line}{expand}")- // let mbr = info- // .multibuffer_row- // .map(|row| format!("{:0>3}", row.0))- // .unwrap_or_else(|| "???".to_string());- // let byte_range = format!("{byte_range_start:0>3}..{byte_range_end:0>3}");- // format!("{boundary_row}Row: {mbr}, Bytes: {byte_range} | {marker}{line}{expand}")- })- .collect::<Vec<_>>()- .join("\n")+ if has_bit != is_tab {+ eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());+ eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);+ assert_eq!(+ has_bit, is_tab,+ "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",+ byte_idx, chunk_text, byte as char, is_tab, has_bit+ );+ }+ }+ }}-// fn format_transforms(snapshot: &MultiBufferSnapshot) -> String {-// snapshot-// .diff_transforms-// .iter()-// .map(|transform| {-// let (kind, summary) = match transform {-// DiffTransform::DeletedHunk { summary, .. } => (" Deleted", (*summary).into()),-// DiffTransform::FilteredInsertedHunk { summary, .. } => (" Filtered", *summary),-// DiffTransform::InsertedHunk { summary, .. } => (" Inserted", *summary),-// DiffTransform::Unmodified { summary, .. } => ("Unmodified", *summary),-// };-// format!("{kind}(len: {}, lines: {:?})", summary.len, summary.lines)-// })-// .join("\n")-// }+#[gpui::test(iterations = 10)]+fn test_random_chunk_bitmaps_with_diffs(cx: &mut App, mut rng: StdRng) {+ let settings_store = SettingsStore::test(cx);+ cx.set_global(settings_store);+ use buffer_diff::BufferDiff;+ use util::RandomCharIter;-// fn format_excerpts(snapshot: &MultiBufferSnapshot) -> String {-// snapshot-// .excerpts-// .iter()-// .map(|excerpt| {-// format!(-// "Excerpt(buffer_range = {:?}, lines = {:?}, has_trailing_newline = {:?})",-// excerpt.range.context.to_point(&excerpt.buffer),-// excerpt.text_summary.lines,-// excerpt.has_trailing_newline-// )-// })-// .join("\n")-// }+ let multibuffer = if rng.random() {+ let len = rng.random_range(100..10000);+ let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();+ let buffer = cx.new(|cx| Buffer::local(text, cx));+ cx.new(|cx| MultiBuffer::singleton(buffer, cx))+ } else {+ MultiBuffer::build_random(&mut rng, cx)+ };-#[gpui::test]-async fn test_singleton_with_inverted_diff(cx: &mut TestAppContext) {- let text = indoc!(- "- ZERO- one- TWO- three- six- "- );- let base_text = indoc!(- "- one- two- three- four- five- six- "- );+ let _diff_count = rng.random_range(1..5);+ let mut diffs = Vec::new();- let buffer = cx.new(|cx| Buffer::local(text, cx));- let diff = cx- .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));- cx.run_until_parked();+ multibuffer.update(cx, |multibuffer, cx| {+ let snapshot = multibuffer.snapshot(cx);+ for buffer_id in snapshot.all_buffer_ids() {+ if rng.random_bool(0.7) {+ if let Some(buffer_handle) = multibuffer.buffer(buffer_id) {+ let buffer_text = buffer_handle.read(cx).text();+ let mut base_text = String::new();- let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());+ for line in buffer_text.lines() {+ if rng.random_bool(0.3) {+ continue;+ } else if rng.random_bool(0.3) {+ let line_len = rng.random_range(0..50);+ let modified_line = RandomCharIter::new(&mut rng)+ .take(line_len)+ .collect::<String>();+ base_text.push_str(&modified_line);+ base_text.push('\n');+ } else {+ base_text.push_str(line);+ base_text.push('\n');+ }+ }- let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);- multibuffer.set_all_diff_hunks_expanded(cx);- multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);- multibuffer+ if rng.random_bool(0.5) {+ let extra_lines = rng.random_range(1..5);+ for _ in 0..extra_lines {+ let line_len = rng.random_range(0..50);+ let extra_line = RandomCharIter::new(&mut rng)+ .take(line_len)+ .collect::<String>();+ base_text.push_str(&extra_line);+ base_text.push('\n');+ }+ }++ let diff = cx.new(|cx| {+ BufferDiff::new_with_base_text(+ &base_text,+ &buffer_handle.read(cx).text_snapshot(),+ cx,+ )+ });+ diffs.push(diff.clone());+ multibuffer.add_diff(diff, cx);+ }+ }+ }});- let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {- (multibuffer.snapshot(cx), multibuffer.subscribe())+ multibuffer.update(cx, |multibuffer, cx| {+ if rng.random_bool(0.5) {+ multibuffer.set_all_diff_hunks_expanded(cx);+ } else {+ let snapshot = multibuffer.snapshot(cx);+ let text = snapshot.text();++ let mut ranges = Vec::new();+ for _ in 0..rng.random_range(1..5) {+ if snapshot.len().0 == 0 {+ break;+ }++ let diff_size = rng.random_range(5..1000);+ let mut start = rng.random_range(0..snapshot.len().0);++ while !text.is_char_boundary(start) {+ start = start.saturating_sub(1);+ }++ let mut end = rng.random_range(start..snapshot.len().0.min(start + diff_size));++ while !text.is_char_boundary(end) {+ end = end.saturating_add(1);+ }+ let start_anchor = snapshot.anchor_after(MultiBufferOffset(start));+ let end_anchor = snapshot.anchor_before(MultiBufferOffset(end));+ ranges.push(start_anchor..end_anchor);+ }+ multibuffer.expand_diff_hunks(ranges, cx);+ }});- assert_eq!(snapshot.text(), base_text);- assert_new_snapshot(- &multibuffer,- &mut snapshot,- &mut subscription,- cx,- indoc!(- "- one- - two- three- - four- - five- six- "- ),- );+ let snapshot = multibuffer.read(cx).snapshot(cx);- buffer.update(cx, |buffer, cx| {- buffer.edit_via_marked_text(- indoc!(- "- ZERO- one- «<inserted>»W«O- T»hree- six- "- ),- None,- 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_snapshot,- &base_text_snapshot,- Some(Arc::from(base_text)),- cx,- )- })- .await;- diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));- cx.run_until_parked();-- assert_new_snapshot(- &multibuffer,- &mut snapshot,- &mut subscription,- cx,- indoc! {- "- one- - two- - three- - four- - five- six- "+ let chunks = snapshot.chunks(+ MultiBufferOffset(0)..snapshot.len(),+ LanguageAwareStyling {+ tree_sitter: false,+ diagnostics: false,},);- buffer.update(cx, |buffer, cx| {- 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_snapshot,- &base_text_snapshot,- Some(Arc::from(base_text)),- cx,- )- })- .await;- diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));- cx.run_until_parked();+ for chunk in chunks {+ let chunk_text = chunk.text;+ let chars_bitmap = chunk.chars;+ let tabs_bitmap = chunk.tabs;- assert_new_snapshot(- &multibuffer,- &mut snapshot,- &mut subscription,- cx,- indoc! {- "- - one- - two- - three- - four- - five- - six- "- },- );+ if chunk_text.is_empty() {+ assert_eq!(+ chars_bitmap, 0,+ "Empty chunk should have empty chars bitmap"+ );+ assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");+ continue;+ }- diff.update(cx, |diff, cx| {- diff.set_base_text(- Some("new base\n".into()),- buffer.read(cx).text_snapshot(),- cx,- )- })- .await;- cx.run_until_parked();+ assert!(+ chunk_text.len() <= 128,+ "Chunk text length {} exceeds 128 bytes",+ chunk_text.len()+ );- assert_new_snapshot(- &multibuffer,- &mut snapshot,- &mut subscription,- cx,- indoc! {"- - new base- "},- );+ let char_indices = chunk_text+ .char_indices()+ .map(|(i, _)| i)+ .collect::<Vec<_>>();++ for byte_idx in 0..chunk_text.len() {+ let should_have_bit = char_indices.contains(&byte_idx);+ let has_bit = chars_bitmap & (1 << byte_idx) != 0;++ if has_bit != should_have_bit {+ eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());+ eprintln!("Char indices: {:?}", char_indices);+ eprintln!("Chars bitmap: {:#b}", chars_bitmap);+ }++ assert_eq!(+ has_bit, should_have_bit,+ "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",+ byte_idx, chunk_text, should_have_bit, has_bit+ );+ }++ for (byte_idx, byte) in chunk_text.bytes().enumerate() {+ let is_tab = byte == b'\t';+ let has_bit = tabs_bitmap & (1 << byte_idx) != 0;++ if has_bit != is_tab {+ eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());+ eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);+ assert_eq!(+ has_bit, is_tab,+ "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",+ byte_idx, chunk_text, byte as char, is_tab, has_bit+ );+ }+ }+ }}#[gpui::test]-async fn test_inverted_diff_base_text_change(cx: &mut TestAppContext) {- let base_text = "aaa\nbbb\nccc\n";- let text = "ddd\n";- let buffer = cx.new(|cx| Buffer::local(text, cx));- let diff = cx- .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));- cx.run_until_parked();+async fn test_word_diff_simple_replacement(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| SettingsStore::test(cx));+ cx.set_global(settings_store);- let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());+ let base_text = "hello world foo bar\n";+ let modified_text = "hello WORLD foo BAR\n";- let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);- multibuffer.set_all_diff_hunks_expanded(cx);- multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);- multibuffer- });+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);- let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {- (multibuffer.snapshot(cx), multibuffer.subscribe())- });+ assert_eq!(word_diffs, vec!["world", "bar", "WORLD", "BAR"]);+}- assert_eq!(snapshot.text(), base_text);- assert_new_snapshot(- &multibuffer,- &mut snapshot,- &mut subscription,- cx,- indoc!(- "- - aaa- - bbb- - ccc- "- ),- );+#[gpui::test]+async fn test_word_diff_white_space(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| SettingsStore::test(cx));+ cx.set_global(settings_store);- diff.update(cx, |diff, cx| {- diff.set_base_text(Some("ddd\n".into()), buffer.read(cx).text_snapshot(), cx)- })- .await;+ let base_text = "hello world foo bar\n";+ let modified_text = " hello world foo bar\n";- let _hunks: Vec<_> = multibuffer- .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))- .diff_hunks()- .collect();+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);++ assert_eq!(word_diffs, vec![" "]);}#[gpui::test]-async fn test_inverted_diff_secondary_version_mismatch(cx: &mut TestAppContext) {- let base_text = "one\ntwo\nthree\nfour\nfive\n";- let index_text = "one\nTWO\nthree\nfour\nfive\n";- let buffer_text = "one\nTWO\nthree\nFOUR\nfive\n";+async fn test_word_diff_consecutive_modified_lines(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| SettingsStore::test(cx));+ cx.set_global(settings_store);- let buffer = cx.new(|cx| Buffer::local(buffer_text, cx));+ let base_text = "aaa bbb\nccc ddd\n";+ let modified_text = "aaa BBB\nccc DDD\n";- let unstaged_diff = cx- .new(|cx| BufferDiff::new_with_base_text(index_text, &buffer.read(cx).text_snapshot(), cx));- cx.run_until_parked();+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);- let uncommitted_diff = cx.new(|cx| {- let mut diff =- BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx);- diff.set_secondary_diff(unstaged_diff.clone());- diff- });- cx.run_until_parked();+ assert_eq!(+ word_diffs,+ vec!["bbb", "ddd", "BBB", "DDD"],+ "consecutive modified lines should produce word diffs when line counts match"+ );+}- buffer.update(cx, |buffer, cx| {- buffer.edit([(0..0, "ZERO\n")], None, cx);- });+#[gpui::test]+async fn test_word_diff_modified_lines_with_deletion_between(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| SettingsStore::test(cx));+ cx.set_global(settings_store);- 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_snapshot,- &base_text_snapshot,- Some(Arc::from(index_text)),- cx,- )- })- .await;- unstaged_diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));+ let base_text = "aaa bbb\ndeleted line\nccc ddd\n";+ let modified_text = "aaa BBB\nccc DDD\n";- let base_text_buffer =- uncommitted_diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());-- let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);- multibuffer.set_all_diff_hunks_expanded(cx);- multibuffer.add_inverted_diff(uncommitted_diff.clone(), buffer.clone(), cx);- multibuffer- });+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);- let _hunks: Vec<_> = multibuffer- .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))- .diff_hunks()- .collect();+ assert_eq!(+ word_diffs,+ Vec::<String>::new(),+ "modified lines with a deleted line between should not produce word diffs"+ );}-#[track_caller]-fn assert_excerpts_match(- multibuffer: &Entity<MultiBuffer>,- cx: &mut TestAppContext,- expected: &str,-) {- let mut output = String::new();- multibuffer.read_with(cx, |multibuffer, cx| {- let snapshot = multibuffer.snapshot(cx);- for excerpt in multibuffer.snapshot(cx).excerpts() {- output.push_str("-----\n");- output.extend(- snapshot- .buffer_for_id(excerpt.context.start.buffer_id)- .unwrap()- .text_for_range(excerpt.context),- );- if !output.ends_with('\n') {- output.push('\n');- }- }+#[gpui::test]+async fn test_word_diff_disabled(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| {+ let mut settings_store = SettingsStore::test(cx);+ settings_store.update_user_settings(cx, |settings| {+ settings.project.all_languages.defaults.word_diff_enabled = Some(false);+ });+ settings_store});- assert_eq!(output, expected);-}+ cx.set_global(settings_store);-#[track_caller]-fn assert_new_snapshot(- multibuffer: &Entity<MultiBuffer>,- snapshot: &mut MultiBufferSnapshot,- subscription: &mut Subscription<MultiBufferOffset>,- cx: &mut TestAppContext,- expected_diff: &str,-) {- let new_snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- let actual_text = new_snapshot.text();- let line_infos = new_snapshot- .row_infos(MultiBufferRow(0))- .collect::<Vec<_>>();- let actual_diff = format_diff(&actual_text, &line_infos, &Default::default(), None);- pretty_assertions::assert_eq!(actual_diff, expected_diff);- check_edits(- snapshot,- &new_snapshot,- &subscription.consume().into_inner(),+ let base_text = "hello world\n";+ let modified_text = "hello WORLD\n";++ let word_diffs = collect_word_diffs(base_text, modified_text, cx);++ assert_eq!(+ word_diffs,+ Vec::<String>::new(),+ "word diffs should be empty when disabled");- *snapshot = new_snapshot;}-#[track_caller]-fn check_edits(- old_snapshot: &MultiBufferSnapshot,- new_snapshot: &MultiBufferSnapshot,- edits: &[Edit<MultiBufferOffset>],-) {- let mut text = old_snapshot.text();- let new_text = new_snapshot.text();- for edit in edits.iter().rev() {- if !text.is_char_boundary(edit.old.start.0)- || !text.is_char_boundary(edit.old.end.0)- || !new_text.is_char_boundary(edit.new.start.0)- || !new_text.is_char_boundary(edit.new.end.0)- {- panic!(- "invalid edits: {:?}\nold text: {:?}\nnew text: {:?}",- edits, text, new_text- );- }+#[gpui::test]+async fn test_word_diff_expanded_cjk(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| SettingsStore::test(cx));+ cx.set_global(settings_store);- text.replace_range(- edit.old.start.0..edit.old.end.0,- &new_text[edit.new.start.0..edit.new.end.0],- );- }+ let base_text = "line 0\nline 1\nhello ab\n";+ let modified_text = "line 0\nline 1\nhello 写入\n";- pretty_assertions::assert_eq!(text, new_text, "invalid edits: {:?}", edits);+ let multibuffer = create_multibuffer_with_diff(base_text, modified_text, cx);+ multibuffer.update(cx, |mb, cx| {+ mb.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);+ });++ let snapshot = multibuffer.read_with(cx, |mb, cx| mb.snapshot(cx));+ let highlighted = assert_word_diff_ranges_valid(&snapshot);+ assert_eq!(highlighted, vec!["ab", "写入"]);}-#[track_caller]-fn assert_chunks_in_ranges(snapshot: &MultiBufferSnapshot) {- let full_text = snapshot.text();- for ix in 0..full_text.len() {- let mut chunks = snapshot.chunks(- MultiBufferOffset(0)..snapshot.len(),- LanguageAwareStyling {- tree_sitter: false,- diagnostics: false,- },- );- chunks.seek(MultiBufferOffset(ix)..snapshot.len());- let tail = chunks.map(|chunk| chunk.text).collect::<String>();- assert_eq!(tail, &full_text[ix..], "seek to range: {:?}", ix..);- }+#[gpui::test]+async fn test_word_diff_byte_132_collapsed(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| SettingsStore::test(cx));+ cx.set_global(settings_store);++ let prefix = "x".repeat(129);+ let base_text = format!("{prefix} ab\n");+ let modified_text = format!("{prefix} 写入\n");++ let multibuffer = create_multibuffer_with_diff(&base_text, &modified_text, cx);+ let snapshot = multibuffer.read_with(cx, |mb, cx| mb.snapshot(cx));+ let highlighted = assert_word_diff_ranges_valid(&snapshot);+ assert_eq!(highlighted, vec!["写入"]);}-#[track_caller]-fn assert_consistent_line_numbers(snapshot: &MultiBufferSnapshot) {- let all_line_numbers = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();- for start_row in 1..all_line_numbers.len() {- let line_numbers = snapshot- .row_infos(MultiBufferRow(start_row as u32))- .collect::<Vec<_>>();- assert_eq!(- line_numbers,- all_line_numbers[start_row..],- "start_row: {start_row}"- );- }+#[gpui::test]+async fn test_word_diff_byte_132_expanded(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| SettingsStore::test(cx));+ cx.set_global(settings_store);++ let prefix = "x".repeat(129);+ let base_text = format!("{prefix} ab\n");+ let modified_text = format!("{prefix} 写入\n");++ let multibuffer = create_multibuffer_with_diff(&base_text, &modified_text, cx);+ multibuffer.update(cx, |mb, cx| {+ mb.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);+ });++ let snapshot = multibuffer.read_with(cx, |mb, cx| mb.snapshot(cx));+ let highlighted = assert_word_diff_ranges_valid(&snapshot);+ assert_eq!(highlighted, vec!["ab", "写入"]);}-#[track_caller]-fn assert_position_translation(snapshot: &MultiBufferSnapshot) {- let text = Rope::from(snapshot.text());+#[gpui::test]+async fn test_word_diff_mixed_expanded_and_collapsed(cx: &mut TestAppContext) {+ let settings_store = cx.update(|cx| SettingsStore::test(cx));+ cx.set_global(settings_store);- let mut left_anchors = Vec::new();- let mut right_anchors = Vec::new();- let mut offsets = Vec::new();- let mut points = Vec::new();- for offset in 0..=text.len() + 1 {- let offset = MultiBufferOffset(offset);- let clipped_left = snapshot.clip_offset(offset, Bias::Left);- let clipped_right = snapshot.clip_offset(offset, Bias::Right);- assert_eq!(- clipped_left.0,- text.clip_offset(offset.0, Bias::Left),- "clip_offset({offset:?}, Left)"- );- assert_eq!(- clipped_right.0,- text.clip_offset(offset.0, Bias::Right),- "clip_offset({offset:?}, Right)"- );- assert_eq!(- snapshot.offset_to_point(clipped_left),- text.offset_to_point(clipped_left.0),- "offset_to_point({})",- clipped_left.0- );- assert_eq!(- snapshot.offset_to_point(clipped_right),- text.offset_to_point(clipped_right.0),- "offset_to_point({})",- clipped_right.0- );- let anchor_after = snapshot.anchor_after(clipped_left);- assert_eq!(- anchor_after.to_offset(snapshot),- clipped_left,- "anchor_after({}).to_offset {anchor_after:?}",- clipped_left.0- );- let anchor_before = snapshot.anchor_before(clipped_left);- assert_eq!(- anchor_before.to_offset(snapshot),- clipped_left,- "anchor_before({}).to_offset",- clipped_left.0- );- left_anchors.push(anchor_before);- right_anchors.push(anchor_after);- offsets.push(clipped_left);- points.push(text.offset_to_point(clipped_left.0));- }+ let prefix = "x".repeat(129);+ let base_text = format!("first alpha\nmiddle 1\nmiddle 2\n{prefix} ab\n");+ let modified_text = format!("first BETA\nmiddle 1\nmiddle 2\n{prefix} 写入\n");- for row in 0..text.max_point().row {- for column in 0..text.line_len(row) + 1 {- let point = Point { row, column };- let clipped_left = snapshot.clip_point(point, Bias::Left);- let clipped_right = snapshot.clip_point(point, Bias::Right);- assert_eq!(- clipped_left,- text.clip_point(point, Bias::Left),- "clip_point({point:?}, Left)"- );- assert_eq!(- clipped_right,- text.clip_point(point, Bias::Right),- "clip_point({point:?}, Right)"- );- assert_eq!(- snapshot.point_to_offset(clipped_left).0,- text.point_to_offset(clipped_left),- "point_to_offset({clipped_left:?})"- );- assert_eq!(- snapshot.point_to_offset(clipped_right).0,- text.point_to_offset(clipped_right),- "point_to_offset({clipped_right:?})"- );- }- }+ let multibuffer = create_multibuffer_with_diff(&base_text, &modified_text, cx);- assert_eq!(- snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&left_anchors),- offsets,- "left_anchors <-> offsets"- );- assert_eq!(- snapshot.summaries_for_anchors::<Point, _>(&left_anchors),- points,- "left_anchors <-> points"- );- assert_eq!(- snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&right_anchors),- offsets,- "right_anchors <-> offsets"- );- assert_eq!(- snapshot.summaries_for_anchors::<Point, _>(&right_anchors),- points,- "right_anchors <-> points"- );+ let hunks: Vec<_> = multibuffer+ .read_with(cx, |mb, cx| mb.snapshot(cx))+ .diff_hunks()+ .collect();+ assert_eq!(hunks.len(), 2, "expected 2 distinct diff hunks");- for (anchors, bias) in [(&left_anchors, Bias::Left), (&right_anchors, Bias::Right)] {- for (ix, (offset, anchor)) in offsets.iter().zip(anchors).enumerate() {- if ix > 0 && *offset == MultiBufferOffset(252) && offset > &offsets[ix - 1] {- let prev_anchor = left_anchors[ix - 1];- assert!(- anchor.cmp(&prev_anchor, snapshot).is_gt(),- "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_gt()",- offsets[ix],- offsets[ix - 1],- );- assert!(- prev_anchor.cmp(anchor, snapshot).is_lt(),- "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_lt()",- offsets[ix - 1],- offsets[ix],- );- }- }- }-- if let Some((buffer, offset)) = snapshot.point_to_buffer_offset(snapshot.max_point()) {- assert!(offset.0 <= buffer.len());- }- if let Some((buffer, point)) = snapshot.point_to_buffer_point(snapshot.max_point()) {- assert!(point <= buffer.max_point());- }-}--fn assert_line_indents(snapshot: &MultiBufferSnapshot) {- let max_row = snapshot.max_point().row;- let buffer_id = snapshot.excerpts().next().unwrap().context.start.buffer_id;- let text = text::Buffer::new(ReplicaId::LOCAL, buffer_id, snapshot.text());- let mut line_indents = text- .line_indents_in_row_range(0..max_row + 1)- .collect::<Vec<_>>();- for start_row in 0..snapshot.max_point().row {- pretty_assertions::assert_eq!(- snapshot- .line_indents(MultiBufferRow(start_row), |_| true)- .map(|(row, indent, _)| (row.0, indent))- .collect::<Vec<_>>(),- &line_indents[(start_row as usize)..],- "line_indents({start_row})"- );- }-- line_indents.reverse();- pretty_assertions::assert_eq!(- snapshot- .reversed_line_indents(MultiBufferRow(max_row), |_| true)- .map(|(row, indent, _)| (row.0, indent))- .collect::<Vec<_>>(),- &line_indents[..],- "reversed_line_indents({max_row})"- );-}--#[gpui::test]-fn test_new_empty_buffer_uses_untitled_title(cx: &mut App) {- let buffer = cx.new(|cx| Buffer::local("", cx));- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));+ // Expand ONLY the first hunk, leaving the second hunk collapsed+ multibuffer.update(cx, |mb, cx| {+ mb.expand_diff_hunks(vec![hunks[0].multi_buffer_range.clone()], cx);+ });- assert_eq!(multibuffer.read(cx).title(cx), "untitled");+ let snapshot = multibuffer.read_with(cx, |mb, cx| mb.snapshot(cx));+ let highlighted = assert_word_diff_ranges_valid(&snapshot);+ // Hunk 1 (expanded) yields deleted + modified words: ["alpha", "BETA"]+ // Hunk 2 (collapsed) yields modified word only: ["写入"]+ assert_eq!(highlighted, vec!["alpha", "BETA", "写入"]);}+/// Tests `excerpt_containing` and `excerpts_for_range` (functions mapping multi-buffer text-coordinates to excerpts)#[gpui::test]-fn test_new_empty_buffer_uses_untitled_title_when_only_contains_whitespace(cx: &mut App) {- let buffer = cx.new(|cx| Buffer::local("\n ", cx));- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));+fn test_excerpts_containment_functions(cx: &mut App) {+ // Multibuffer content for these tests:+ // 0123+ // 0: aa0+ // 1: aa1+ // -----+ // 2: bb0+ // 3: bb1+ // -----MultiBufferOffset(0)..+ // 4: cc0- assert_eq!(multibuffer.read(cx).title(cx), "untitled");-}+ let buffer_1 = cx.new(|cx| Buffer::local("aa0\naa1", cx));+ let buffer_2 = cx.new(|cx| Buffer::local("bb0\nbb1", cx));+ let buffer_3 = cx.new(|cx| Buffer::local("cc0", cx));-#[gpui::test]-fn test_new_empty_buffer_takes_first_line_for_title(cx: &mut App) {- let buffer = cx.new(|cx| Buffer::local("Hello World\nSecond line", cx));- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));- assert_eq!(multibuffer.read(cx).title(cx), "Hello World");-}+ let (excerpt_1_info, excerpt_2_info, excerpt_3_info) =+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer_1.clone(),+ [Point::new(0, 0)..Point::new(1, 3)],+ 0,+ cx,+ );-#[gpui::test]-fn test_new_empty_buffer_takes_trimmed_first_line_for_title(cx: &mut App) {- let buffer = cx.new(|cx| Buffer::local("\nHello, World ", cx));- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(1),+ buffer_2.clone(),+ [Point::new(0, 0)..Point::new(1, 3)],+ 0,+ cx,+ );- assert_eq!(multibuffer.read(cx).title(cx), "Hello, World");-}+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(2),+ buffer_3.clone(),+ [Point::new(0, 0)..Point::new(0, 3)],+ 0,+ cx,+ );-#[gpui::test]-fn test_new_empty_buffer_uses_truncated_first_line_for_title(cx: &mut App) {- let title = "aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeee";- let title_after = "aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd";- let buffer = cx.new(|cx| Buffer::local(title, cx));- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));+ let snapshot = multibuffer.snapshot(cx);+ let mut excerpts = snapshot.excerpts();+ (+ excerpts.next().unwrap(),+ excerpts.next().unwrap(),+ excerpts.next().unwrap(),+ )+ });- assert_eq!(multibuffer.read(cx).title(cx), title_after);-}+ let snapshot = multibuffer.read(cx).snapshot(cx);-#[gpui::test]-fn test_new_empty_buffer_uses_truncated_first_line_for_title_after_merging_adjacent_spaces(- cx: &mut App,-) {- let title = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddddeeeeeeeeee";- let title_after = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddd";- let buffer = cx.new(|cx| Buffer::local(title, cx));- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));+ assert_eq!(snapshot.text(), "aa0\naa1\nbb0\nbb1\ncc0");- assert_eq!(multibuffer.read(cx).title(cx), title_after);-}+ //// Test `excerpts_for_range`-#[gpui::test]-fn test_new_empty_buffers_title_can_be_set(cx: &mut App) {- let buffer = cx.new(|cx| Buffer::local("Hello World", cx));- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));- assert_eq!(multibuffer.read(cx).title(cx), "Hello World");+ let p00 = snapshot.point_to_offset(Point::new(0, 0));+ let p10 = snapshot.point_to_offset(Point::new(1, 0));+ let p20 = snapshot.point_to_offset(Point::new(2, 0));+ let p23 = snapshot.point_to_offset(Point::new(2, 3));+ let p13 = snapshot.point_to_offset(Point::new(1, 3));+ let p40 = snapshot.point_to_offset(Point::new(4, 0));+ let p43 = snapshot.point_to_offset(Point::new(4, 3));- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_title("Hey".into(), cx)- });- assert_eq!(multibuffer.read(cx).title(cx), "Hey");-}+ let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p00).collect();+ assert_eq!(excerpts.len(), 1);+ assert_eq!(excerpts[0].range, excerpt_1_info);-#[gpui::test(iterations = 100)]-fn test_random_chunk_bitmaps(cx: &mut App, mut rng: StdRng) {- let multibuffer = if rng.random() {- let len = rng.random_range(0..10000);- let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();- let buffer = cx.new(|cx| Buffer::local(text, cx));- cx.new(|cx| MultiBuffer::singleton(buffer, cx))- } else {- MultiBuffer::build_random(&mut rng, cx)- };+ // Cursor at very end of excerpt 3+ let excerpts: Vec<_> = snapshot.excerpts_for_range(p43..p43).collect();+ assert_eq!(excerpts.len(), 1);+ assert_eq!(excerpts[0].range, excerpt_3_info);- let snapshot = multibuffer.read(cx).snapshot(cx);+ let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p23).collect();+ assert_eq!(excerpts.len(), 2);+ assert_eq!(excerpts[0].range, excerpt_1_info);+ assert_eq!(excerpts[1].range, excerpt_2_info);- let chunks = snapshot.chunks(- MultiBufferOffset(0)..snapshot.len(),- LanguageAwareStyling {- tree_sitter: false,- diagnostics: false,- },- );+ // This range represent an selection with end-point just inside excerpt_2+ // Today we only expand the first excerpt, but another interpretation that+ // we could consider is expanding both here+ let excerpts: Vec<_> = snapshot.excerpts_for_range(p10..p20).collect();+ assert_eq!(excerpts.len(), 1);+ assert_eq!(excerpts[0].range, excerpt_1_info);- for chunk in chunks {- let chunk_text = chunk.text;- let chars_bitmap = chunk.chars;- let tabs_bitmap = chunk.tabs;+ //// Test that `excerpts_for_range` and `excerpt_containing` agree for all single offsets (cursor positions)+ for offset in 0..=snapshot.len().0 {+ let offset = MultiBufferOffset(offset);+ let excerpts_for_range: Vec<_> = snapshot.excerpts_for_range(offset..offset).collect();+ assert_eq!(+ excerpts_for_range.len(),+ 1,+ "Expected exactly one excerpt for offset {offset}",+ );- if chunk_text.is_empty() {- assert_eq!(- chars_bitmap, 0,- "Empty chunk should have empty chars bitmap"- );- assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");- continue;- }+ let (_, excerpt_containing) =+ snapshot+ .excerpt_containing(offset..offset)+ .unwrap_or_else(|| {+ panic!("Expected excerpt_containing to find excerpt for offset {offset}")+ });- assert!(- chunk_text.len() <= 128,- "Chunk text length {} exceeds 128 bytes",- chunk_text.len()+ assert_eq!(+ excerpts_for_range[0].range, excerpt_containing,+ "excerpts_for_range and excerpt_containing should agree for offset {offset}",);+ }- // Verify chars bitmap- let char_indices = chunk_text- .char_indices()- .map(|(i, _)| i)- .collect::<Vec<_>>();+ //// Test `excerpt_containing` behavior with ranges:- for byte_idx in 0..chunk_text.len() {- let should_have_bit = char_indices.contains(&byte_idx);- let has_bit = chars_bitmap & (1 << byte_idx) != 0;+ // Ranges intersecting a single-excerpt+ let (_, containing) = snapshot.excerpt_containing(p00..p13).unwrap();+ assert_eq!(containing, excerpt_1_info);- if has_bit != should_have_bit {- eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());- eprintln!("Char indices: {:?}", char_indices);- eprintln!("Chars bitmap: {:#b}", chars_bitmap);- }+ // Ranges intersecting multiple excerpts (should return None)+ let containing = snapshot.excerpt_containing(p20..p40);+ assert!(+ containing.is_none(),+ "excerpt_containing should return None for ranges spanning multiple excerpts"+ );+}- assert_eq!(- has_bit, should_have_bit,- "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",- byte_idx, chunk_text, should_have_bit, has_bit- );- }-- for (byte_idx, byte) in chunk_text.bytes().enumerate() {- let is_tab = byte == b'\t';- let has_bit = tabs_bitmap & (1 << byte_idx) != 0;-- if has_bit != is_tab {- eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());- eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);- assert_eq!(- has_bit, is_tab,- "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",- byte_idx, chunk_text, byte as char, is_tab, has_bit- );- }- }- }-}--#[gpui::test(iterations = 10)]-fn test_random_chunk_bitmaps_with_diffs(cx: &mut App, mut rng: StdRng) {- let settings_store = SettingsStore::test(cx);- cx.set_global(settings_store);- use buffer_diff::BufferDiff;- use util::RandomCharIter;-- let multibuffer = if rng.random() {- let len = rng.random_range(100..10000);- let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();- let buffer = cx.new(|cx| Buffer::local(text, cx));- cx.new(|cx| MultiBuffer::singleton(buffer, cx))- } else {- MultiBuffer::build_random(&mut rng, cx)- };-- let _diff_count = rng.random_range(1..5);- let mut diffs = Vec::new();-- multibuffer.update(cx, |multibuffer, cx| {- let snapshot = multibuffer.snapshot(cx);- for buffer_id in snapshot.all_buffer_ids() {- if rng.random_bool(0.7) {- if let Some(buffer_handle) = multibuffer.buffer(buffer_id) {- let buffer_text = buffer_handle.read(cx).text();- let mut base_text = String::new();-- for line in buffer_text.lines() {- if rng.random_bool(0.3) {- continue;- } else if rng.random_bool(0.3) {- let line_len = rng.random_range(0..50);- let modified_line = RandomCharIter::new(&mut rng)- .take(line_len)- .collect::<String>();- base_text.push_str(&modified_line);- base_text.push('\n');- } else {- base_text.push_str(line);- base_text.push('\n');- }- }-- if rng.random_bool(0.5) {- let extra_lines = rng.random_range(1..5);- for _ in 0..extra_lines {- let line_len = rng.random_range(0..50);- let extra_line = RandomCharIter::new(&mut rng)- .take(line_len)- .collect::<String>();- base_text.push_str(&extra_line);- base_text.push('\n');- }- }-- let diff = cx.new(|cx| {- BufferDiff::new_with_base_text(- &base_text,- &buffer_handle.read(cx).text_snapshot(),- cx,- )- });- diffs.push(diff.clone());- multibuffer.add_diff(diff, cx);- }- }- }- });+#[gpui::test]+fn test_range_to_buffer_ranges(cx: &mut App) {+ let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));+ let buffer_2 = cx.new(|cx| Buffer::local("ccc", cx));+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));multibuffer.update(cx, |multibuffer, cx| {- if rng.random_bool(0.5) {- multibuffer.set_all_diff_hunks_expanded(cx);- } else {- let snapshot = multibuffer.snapshot(cx);- let text = snapshot.text();-- let mut ranges = Vec::new();- for _ in 0..rng.random_range(1..5) {- if snapshot.len().0 == 0 {- break;- }-- let diff_size = rng.random_range(5..1000);- let mut start = rng.random_range(0..snapshot.len().0);-- while !text.is_char_boundary(start) {- start = start.saturating_sub(1);- }-- let mut end = rng.random_range(start..snapshot.len().0.min(start + diff_size));+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer_1.clone(),+ [Point::new(0, 0)..Point::new(1, 3)],+ 0,+ cx,+ );- while !text.is_char_boundary(end) {- end = end.saturating_add(1);- }- let start_anchor = snapshot.anchor_after(MultiBufferOffset(start));- let end_anchor = snapshot.anchor_before(MultiBufferOffset(end));- ranges.push(start_anchor..end_anchor);- }- multibuffer.expand_diff_hunks(ranges, cx);- }+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(1),+ buffer_2.clone(),+ [Point::new(0, 0)..Point::new(0, 3)],+ 0,+ cx,+ );});let snapshot = multibuffer.read(cx).snapshot(cx);+ assert_eq!(snapshot.text(), "aaa\nbbb\nccc");- let chunks = snapshot.chunks(- MultiBufferOffset(0)..snapshot.len(),- LanguageAwareStyling {- tree_sitter: false,- diagnostics: false,- },- );+ let excerpt_2_start = Point::new(2, 0);- for chunk in chunks {- let chunk_text = chunk.text;- let chars_bitmap = chunk.chars;- let tabs_bitmap = chunk.tabs;+ let ranges_half_open = snapshot.range_to_buffer_ranges(Point::zero()..excerpt_2_start);+ assert_eq!(+ ranges_half_open.len(),+ 1,+ "Half-open range ending at excerpt start should EXCLUDE that excerpt"+ );+ assert_eq!(ranges_half_open[0].1, BufferOffset(0)..BufferOffset(7));+ assert_eq!(+ ranges_half_open[0].0.remote_id(),+ buffer_1.read(cx).remote_id()+ );- if chunk_text.is_empty() {- assert_eq!(- chars_bitmap, 0,- "Empty chunk should have empty chars bitmap"+ let buffer_empty = cx.new(|cx| Buffer::local("", cx));+ let multibuffer_trailing_empty = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+ let (_te_excerpt_1_info, _te_excerpt_2_info) =+ multibuffer_trailing_empty.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer_1.clone(),+ [Point::new(0, 0)..Point::new(1, 3)],+ 0,+ cx,);- assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");- continue;- }-- assert!(- chunk_text.len() <= 128,- "Chunk text length {} exceeds 128 bytes",- chunk_text.len()- );- let char_indices = chunk_text- .char_indices()- .map(|(i, _)| i)- .collect::<Vec<_>>();+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(1),+ buffer_empty.clone(),+ [Point::new(0, 0)..Point::new(0, 0)],+ 0,+ cx,+ );- for byte_idx in 0..chunk_text.len() {- let should_have_bit = char_indices.contains(&byte_idx);- let has_bit = chars_bitmap & (1 << byte_idx) != 0;+ let snapshot = multibuffer.snapshot(cx);+ let mut infos = snapshot.excerpts();+ (infos.next().unwrap(), infos.next().unwrap())+ });- if has_bit != should_have_bit {- eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());- eprintln!("Char indices: {:?}", char_indices);- eprintln!("Chars bitmap: {:#b}", chars_bitmap);- }+ let snapshot_trailing = multibuffer_trailing_empty.read(cx).snapshot(cx);+ assert_eq!(snapshot_trailing.text(), "aaa\nbbb\n");- assert_eq!(- has_bit, should_have_bit,- "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",- byte_idx, chunk_text, should_have_bit, has_bit- );- }+ let max_point = snapshot_trailing.max_point();- for (byte_idx, byte) in chunk_text.bytes().enumerate() {- let is_tab = byte == b'\t';- let has_bit = tabs_bitmap & (1 << byte_idx) != 0;+ let ranges_half_open_max = snapshot_trailing.range_to_buffer_ranges(Point::zero()..max_point);+ assert_eq!(+ ranges_half_open_max.len(),+ 2,+ "Should include trailing empty excerpts"+ );+ assert_eq!(ranges_half_open_max[1].1, BufferOffset(0)..BufferOffset(0));- if has_bit != is_tab {- eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());- eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);- assert_eq!(- has_bit, is_tab,- "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",- byte_idx, chunk_text, byte as char, is_tab, has_bit- );+ for snapshot in [&snapshot, &snapshot_trailing] {+ for start in 0..=snapshot.len().0 {+ for end in start..=snapshot.len().0 {+ let range = MultiBufferOffset(start)..MultiBufferOffset(end);+ let expected = snapshot+ .range_to_buffer_ranges(range.clone())+ .into_iter()+ .map(|(buffer, range, _)| (buffer.remote_id(), range, None))+ .collect::<Vec<_>>();+ let actual = snapshot+ .range_to_buffer_ranges_with_deleted_hunks(range.clone())+ .map(|(buffer, range, anchor)| (buffer.remote_id(), range, anchor))+ .collect::<Vec<_>>();+ assert_eq!(actual, expected, "{range:?}");}}}}-fn collect_word_diffs(- base_text: &str,- modified_text: &str,- cx: &mut TestAppContext,-) -> Vec<String> {- let buffer = cx.new(|cx| Buffer::local(modified_text, cx));+#[gpui::test]+fn test_range_to_buffer_ranges_zero_length_at_excerpt_boundary(cx: &mut App) {+ let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));+ let buffer_2 = cx.new(|cx| Buffer::local("ccc\nddd", cx));++ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer_1.clone(),+ [Point::new(0, 0)..Point::new(1, 3)],+ 0,+ cx,+ );+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(1),+ buffer_2.clone(),+ [Point::new(0, 0)..Point::new(1, 3)],+ 0,+ cx,+ );+ });++ let snapshot = multibuffer.read(cx).snapshot(cx);+ assert_eq!(snapshot.text(), "aaa\nbbb\nccc\nddd");++ // This point is right at the start of the very first excerpt, so if we get+ // a buffer range, we should get `0..0`+ let excerpt_2_start = Point::new(2, 0);+ let expected_ranges = vec![BufferOffset(0)..BufferOffset(0)];+ let ranges = snapshot+ .range_to_buffer_ranges(excerpt_2_start..excerpt_2_start)+ .into_iter()+ .map(|tup| tup.1)+ .collect_vec();++ assert_eq!(+ ranges, expected_ranges,+ "Zero-length range at excerpt boundary should return the excerpt at that point"+ );+}++#[gpui::test]+async fn test_buffer_range_to_excerpt_ranges(cx: &mut TestAppContext) {+ let base_text = indoc!(+ "+ aaa+ bbb+ ccc+ ddd+ eee+ ppp+ qqq+ rrr+ fff+ ggg+ hhh+ "+ );+ let text = indoc!(+ "+ aaa+ BBB+ ddd+ eee+ ppp+ qqq+ rrr+ FFF+ ggg+ hhh+ "+ );++ let buffer = cx.new(|cx| Buffer::local(text, cx));let diff = cx.new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));cx.run_until_parked();let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::singleton(buffer.clone(), cx);+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer.clone(),+ [+ Point::new(0, 0)..Point::new(3, 3),+ Point::new(7, 0)..Point::new(9, 3),+ ],+ 0,+ cx,+ );multibuffer.add_diff(diff.clone(), cx);multibuffer});@@ -6066,1131 +5263,2066 @@ fn collect_word_diffs(multibuffer.update(cx, |multibuffer, cx| {multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);});+ cx.run_until_parked();let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- let text = snapshot.text();- snapshot- .diff_hunks()- .flat_map(|hunk| hunk.word_diffs)- .map(|range| text[range.start.0..range.end.0].to_string())- .collect()-}+ let actual_diff = format_diff(+ &snapshot.text(),+ &snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),+ &Default::default(),+ None,+ );+ let expected_diff = indoc!(+ "+ aaa+ - bbb+ - ccc+ + BBB+ ddd+ eee [\u{2193}]+ - fff [\u{2191}]+ + FFF+ ggg+ hhh [\u{2193}]"+ );+ pretty_assertions::assert_eq!(actual_diff, expected_diff);-#[gpui::test]-async fn test_word_diff_simple_replacement(cx: &mut TestAppContext) {- let settings_store = cx.update(|cx| SettingsStore::test(cx));- cx.set_global(settings_store);+ let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());- let base_text = "hello world foo bar\n";- let modified_text = "hello WORLD foo BAR\n";+ let query_spanning_deleted_hunk = buffer_snapshot.anchor_after(Point::new(0, 0))+ ..buffer_snapshot.anchor_before(Point::new(1, 3));+ assert_eq!(+ snapshot+ .buffer_range_to_excerpt_ranges(query_spanning_deleted_hunk)+ .map(|range| range.to_point(&snapshot))+ .collect::<Vec<_>>(),+ vec![+ Point::new(0, 0)..Point::new(1, 0),+ Point::new(3, 0)..Point::new(3, 3),+ ],+ );- let word_diffs = collect_word_diffs(base_text, modified_text, cx);+ let query_within_contiguous_main_buffer = buffer_snapshot.anchor_after(Point::new(1, 0))+ ..buffer_snapshot.anchor_before(Point::new(2, 3));+ assert_eq!(+ snapshot+ .buffer_range_to_excerpt_ranges(query_within_contiguous_main_buffer)+ .map(|range| range.to_point(&snapshot))+ .collect::<Vec<_>>(),+ vec![Point::new(3, 0)..Point::new(4, 3)],+ );- assert_eq!(word_diffs, vec!["world", "bar", "WORLD", "BAR"]);+ let query_spanning_both_excerpts = buffer_snapshot.anchor_after(Point::new(2, 0))+ ..buffer_snapshot.anchor_before(Point::new(8, 3));+ assert_eq!(+ snapshot+ .buffer_range_to_excerpt_ranges(query_spanning_both_excerpts)+ .map(|range| range.to_point(&snapshot))+ .collect::<Vec<_>>(),+ vec![+ Point::new(4, 0)..Point::new(5, 3),+ Point::new(7, 0)..Point::new(8, 3),+ ],+ );}#[gpui::test]-async fn test_word_diff_white_space(cx: &mut TestAppContext) {- let settings_store = cx.update(|cx| SettingsStore::test(cx));- cx.set_global(settings_store);-- let base_text = "hello world foo bar\n";- let modified_text = " hello world foo bar\n";-- let word_diffs = collect_word_diffs(base_text, modified_text, cx);+fn test_cannot_seek_backward_after_excerpt_replacement(cx: &mut TestAppContext) {+ let buffer_b_text: String = (0..50).map(|i| format!("line_b {i}\n")).collect();+ let buffer_b = cx.new(|cx| Buffer::local(buffer_b_text, cx));- assert_eq!(word_diffs, vec![" "]);-}+ let buffer_c_text: String = (0..10).map(|i| format!("line_c {i}\n")).collect();+ let buffer_c = cx.new(|cx| Buffer::local(buffer_c_text, cx));-#[gpui::test]-async fn test_word_diff_consecutive_modified_lines(cx: &mut TestAppContext) {- let settings_store = cx.update(|cx| SettingsStore::test(cx));- cx.set_global(settings_store);+ let buffer_d_text: String = (0..10).map(|i| format!("line_d {i}\n")).collect();+ let buffer_d = cx.new(|cx| Buffer::local(buffer_d_text, cx));- let base_text = "aaa bbb\nccc ddd\n";- let modified_text = "aaa BBB\nccc DDD\n";+ let path_b = PathKey::with_sort_prefix(0, rel_path("bbb.rs").into_arc());+ let path_c = PathKey::with_sort_prefix(0, rel_path("ddd.rs").into_arc());+ let path_d = PathKey::with_sort_prefix(0, rel_path("ccc.rs").into_arc());- let word_diffs = collect_word_diffs(base_text, modified_text, cx);+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));- assert_eq!(- word_diffs,- vec!["bbb", "ddd", "BBB", "DDD"],- "consecutive modified lines should produce word diffs when line counts match"- );-}+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ path_b.clone(),+ buffer_b.clone(),+ vec![+ Point::row_range(0..3),+ Point::row_range(15..18),+ Point::row_range(30..33),+ ],+ 0,+ cx,+ );+ });-#[gpui::test]-async fn test_word_diff_modified_lines_with_deletion_between(cx: &mut TestAppContext) {- let settings_store = cx.update(|cx| SettingsStore::test(cx));- cx.set_global(settings_store);+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ path_c.clone(),+ buffer_c.clone(),+ vec![Point::row_range(0..3)],+ 0,+ cx,+ );+ });- let base_text = "aaa bbb\ndeleted line\nccc ddd\n";- let modified_text = "aaa BBB\nccc DDD\n";+ let (anchor_in_e_b2, anchor_in_e_b3) = multibuffer.read_with(cx, |multibuffer, cx| {+ let snapshot = multibuffer.snapshot(cx);+ let excerpt_infos = snapshot.excerpts().collect::<Vec<_>>();+ assert_eq!(excerpt_infos.len(), 4, "expected 4 excerpts (3×B + 1×C)");- let word_diffs = collect_word_diffs(base_text, modified_text, cx);+ let e_b2_info = excerpt_infos[1].clone();+ let e_b3_info = excerpt_infos[2].clone();- assert_eq!(- word_diffs,- Vec::<String>::new(),- "modified lines with a deleted line between should not produce word diffs"- );-}+ let anchor_b2 = snapshot.anchor_in_excerpt(e_b2_info.context.start).unwrap();+ let anchor_b3 = snapshot.anchor_in_excerpt(e_b3_info.context.start).unwrap();+ (anchor_b2, anchor_b3)+ });-#[gpui::test]-async fn test_word_diff_disabled(cx: &mut TestAppContext) {- let settings_store = cx.update(|cx| {- let mut settings_store = SettingsStore::test(cx);- settings_store.update_user_settings(cx, |settings| {- settings.project.all_languages.defaults.word_diff_enabled = Some(false);- });- settings_store+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ path_b.clone(),+ buffer_b.clone(),+ vec![Point::row_range(0..3), Point::row_range(28..36)],+ 0,+ cx,+ );});- cx.set_global(settings_store);- let base_text = "hello world\n";- let modified_text = "hello WORLD\n";-- let word_diffs = collect_word_diffs(base_text, modified_text, cx);+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpts_for_path(+ path_d.clone(),+ buffer_d.clone(),+ vec![Point::row_range(0..3)],+ 0,+ cx,+ );+ });- assert_eq!(- word_diffs,- Vec::<String>::new(),- "word diffs should be empty when disabled"- );+ multibuffer.read_with(cx, |multibuffer, cx| {+ let snapshot = multibuffer.snapshot(cx);+ snapshot.summaries_for_anchors::<Point, _>(&[anchor_in_e_b2, anchor_in_e_b3]);+ });}-/// Tests `excerpt_containing` and `excerpts_for_range` (functions mapping multi-buffer text-coordinates to excerpts)#[gpui::test]-fn test_excerpts_containment_functions(cx: &mut App) {- // Multibuffer content for these tests:- // 0123- // 0: aa0- // 1: aa1- // ------ // 2: bb0- // 3: bb1- // -----MultiBufferOffset(0)..- // 4: cc0-- let buffer_1 = cx.new(|cx| Buffer::local("aa0\naa1", cx));- let buffer_2 = cx.new(|cx| Buffer::local("bb0\nbb1", cx));- let buffer_3 = cx.new(|cx| Buffer::local("cc0", cx));-- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));-- let (excerpt_1_info, excerpt_2_info, excerpt_3_info) =- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_1.clone(),- [Point::new(0, 0)..Point::new(1, 3)],- 0,- cx,- );-- multibuffer.set_excerpts_for_path(- PathKey::sorted(1),- buffer_2.clone(),- [Point::new(0, 0)..Point::new(1, 3)],- 0,- cx,- );-- multibuffer.set_excerpts_for_path(- PathKey::sorted(2),- buffer_3.clone(),- [Point::new(0, 0)..Point::new(0, 3)],- 0,- cx,- );-- let snapshot = multibuffer.snapshot(cx);- let mut excerpts = snapshot.excerpts();- (- excerpts.next().unwrap(),- excerpts.next().unwrap(),- excerpts.next().unwrap(),- )- });-- let snapshot = multibuffer.read(cx).snapshot(cx);-- assert_eq!(snapshot.text(), "aa0\naa1\nbb0\nbb1\ncc0");-- //// Test `excerpts_for_range`+fn test_resolving_max_anchor_for_buffer(cx: &mut TestAppContext) {+ let dock_base_text = indoc! {"+ 0+ 1+ 2+ 3+ 4+ 5+ 6+ 7+ 8+ 9+ 10+ 11+ 12+ "};- let p00 = snapshot.point_to_offset(Point::new(0, 0));- let p10 = snapshot.point_to_offset(Point::new(1, 0));- let p20 = snapshot.point_to_offset(Point::new(2, 0));- let p23 = snapshot.point_to_offset(Point::new(2, 3));- let p13 = snapshot.point_to_offset(Point::new(1, 3));- let p40 = snapshot.point_to_offset(Point::new(4, 0));- let p43 = snapshot.point_to_offset(Point::new(4, 3));+ let dock_text = indoc! {"+ 0+ 4+ 5+ 6+ 10+ 11+ 12+ "};- let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p00).collect();- assert_eq!(excerpts.len(), 1);- assert_eq!(excerpts[0].range, excerpt_1_info);+ let dock_buffer = cx.new(|cx| Buffer::local(dock_text, cx));+ let diff = cx.new(|cx| {+ BufferDiff::new_with_base_text(dock_base_text, &dock_buffer.read(cx).snapshot(), cx)+ });- // Cursor at very end of excerpt 3- let excerpts: Vec<_> = snapshot.excerpts_for_range(p43..p43).collect();- assert_eq!(excerpts.len(), 1);- assert_eq!(excerpts[0].range, excerpt_3_info);+ let workspace_text = "second buffer\n";+ let workspace_buffer = cx.new(|cx| Buffer::local(workspace_text, cx));- let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p23).collect();- assert_eq!(excerpts.len(), 2);- assert_eq!(excerpts[0].range, excerpt_1_info);- assert_eq!(excerpts[1].range, excerpt_2_info);+ let dock_path = PathKey::with_sort_prefix(0, rel_path("").into_arc());+ let workspace_path = PathKey::with_sort_prefix(1, rel_path("").into_arc());- // This range represent an selection with end-point just inside excerpt_2- // Today we only expand the first excerpt, but another interpretation that- // we could consider is expanding both here- let excerpts: Vec<_> = snapshot.excerpts_for_range(p10..p20).collect();- assert_eq!(excerpts.len(), 1);- assert_eq!(excerpts[0].range, excerpt_1_info);+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));- //// Test that `excerpts_for_range` and `excerpt_containing` agree for all single offsets (cursor positions)- for offset in 0..=snapshot.len().0 {- let offset = MultiBufferOffset(offset);- let excerpts_for_range: Vec<_> = snapshot.excerpts_for_range(offset..offset).collect();- assert_eq!(- excerpts_for_range.len(),- 1,- "Expected exactly one excerpt for offset {offset}",+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.set_excerpt_ranges_for_path(+ dock_path,+ dock_buffer.clone(),+ &dock_buffer.read(cx).snapshot(),+ vec![+ ExcerptRange::new(Point::zero()..Point::new(1, 1)),+ ExcerptRange::new(Point::new(3, 0)..Point::new(4, 2)),+ ],+ cx,);-- let (_, excerpt_containing) =- snapshot- .excerpt_containing(offset..offset)- .unwrap_or_else(|| {- panic!("Expected excerpt_containing to find excerpt for offset {offset}")- });-- assert_eq!(- excerpts_for_range[0].range, excerpt_containing,- "excerpts_for_range and excerpt_containing should agree for offset {offset}",+ multibuffer.set_excerpt_ranges_for_path(+ workspace_path,+ workspace_buffer.clone(),+ &workspace_buffer.read(cx).snapshot(),+ vec![ExcerptRange::new(+ Point::zero()..workspace_buffer.read(cx).max_point(),+ )],+ cx,);- }-- //// Test `excerpt_containing` behavior with ranges:-- // Ranges intersecting a single-excerpt- let (_, containing) = snapshot.excerpt_containing(p00..p13).unwrap();- assert_eq!(containing, excerpt_1_info);+ multibuffer.add_diff(diff, cx);+ multibuffer.set_all_diff_hunks_expanded(cx);+ });- // Ranges intersecting multiple excerpts (should return None)- let containing = snapshot.excerpt_containing(p20..p40);- assert!(- containing.is_none(),- "excerpt_containing should return None for ranges spanning multiple excerpts"+ let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ let diff = format_diff(+ &snapshot.text(),+ &snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),+ &Default::default(),+ None,+ );+ assert_eq!(+ diff,+ indoc! {"+ 0+ - 1+ - 2+ - 3+ 4 [↓]+ 6 [↑]+ - 7+ - 8+ - 9+ 10 [↓]+ second buffer+ "});++ multibuffer.update(cx, |multibuffer, cx| {+ let snapshot = multibuffer.snapshot(cx);+ let point = snapshot+ .anchor_in_buffer(text::Anchor::max_for_buffer(+ dock_buffer.read(cx).remote_id(),+ ))+ .unwrap()+ .to_point(&snapshot);+ assert_eq!(point, Point::new(10, 0));+ })}#[gpui::test]-fn test_range_to_buffer_ranges(cx: &mut App) {- let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));- let buffer_2 = cx.new(|cx| Buffer::local("ccc", cx));+fn test_is_valid_anchor_past_last_excerpt_for_buffer(cx: &mut TestAppContext) {+ let buffer_a = cx.new(|cx| Buffer::local("aaa\nbbb\nccc\n", cx));+ buffer_a.update(cx, |buffer, cx| {+ let len = buffer.len();+ buffer.edit([(len..len, "ddd\neee\n")], None, cx);+ });+ let buffer_b = cx.new(|cx| Buffer::local("xxx\n", cx));+ for line in ["yyy\n", "zzz\n", "www\n", "vvv\n"] {+ buffer_b.update(cx, |buffer, cx| {+ let len = buffer.len();+ buffer.edit([(len..len, line)], None, cx);+ });+ }++ let path_a = PathKey::with_sort_prefix(0, rel_path("aaa.rs").into_arc());+ let path_b = PathKey::with_sort_prefix(1, rel_path("bbb.rs").into_arc());let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+multibuffer.update(cx, |multibuffer, cx| {multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_1.clone(),- [Point::new(0, 0)..Point::new(1, 3)],+ path_a.clone(),+ buffer_a.clone(),+ vec![Point::new(1, 0)..Point::new(2, 3)],0,cx,);-multibuffer.set_excerpts_for_path(- PathKey::sorted(1),- buffer_2.clone(),- [Point::new(0, 0)..Point::new(0, 3)],+ path_b.clone(),+ buffer_b.clone(),+ vec![Point::new(1, 0)..Point::new(3, 3)],0,cx,);});- let snapshot = multibuffer.read(cx).snapshot(cx);- assert_eq!(snapshot.text(), "aaa\nbbb\nccc");-- let excerpt_2_start = Point::new(2, 0);-- let ranges_half_open = snapshot.range_to_buffer_ranges(Point::zero()..excerpt_2_start);- assert_eq!(- ranges_half_open.len(),- 1,- "Half-open range ending at excerpt start should EXCLUDE that excerpt"- );- assert_eq!(ranges_half_open[0].1, BufferOffset(0)..BufferOffset(7));- assert_eq!(- ranges_half_open[0].0.remote_id(),- buffer_1.read(cx).remote_id()- );-- let buffer_empty = cx.new(|cx| Buffer::local("", cx));- let multibuffer_trailing_empty = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));- let (_te_excerpt_1_info, _te_excerpt_2_info) =- multibuffer_trailing_empty.update(cx, |multibuffer, cx| {- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_1.clone(),- [Point::new(0, 0)..Point::new(1, 3)],- 0,- cx,- );-- multibuffer.set_excerpts_for_path(- PathKey::sorted(1),- buffer_empty.clone(),- [Point::new(0, 0)..Point::new(0, 0)],- 0,- cx,- );-- let snapshot = multibuffer.snapshot(cx);- let mut infos = snapshot.excerpts();- (infos.next().unwrap(), infos.next().unwrap())- });-- let snapshot_trailing = multibuffer_trailing_empty.read(cx).snapshot(cx);- assert_eq!(snapshot_trailing.text(), "aaa\nbbb\n");-- let max_point = snapshot_trailing.max_point();+ multibuffer.read_with(cx, |multibuffer, cx| {+ let snapshot = multibuffer.snapshot(cx);- let ranges_half_open_max = snapshot_trailing.range_to_buffer_ranges(Point::zero()..max_point);- assert_eq!(- ranges_half_open_max.len(),- 2,- "Should include trailing empty excerpts"- );- assert_eq!(ranges_half_open_max[1].1, BufferOffset(0)..BufferOffset(0));+ let buffer_a_snapshot = buffer_a.read(cx).snapshot();+ let anchor_past_excerpt = buffer_a_snapshot.anchor_after(Point::new(4, 0));+ let mb_anchor = snapshot.anchor_in_buffer(anchor_past_excerpt).unwrap();- for snapshot in [&snapshot, &snapshot_trailing] {- for start in 0..=snapshot.len().0 {- for end in start..=snapshot.len().0 {- let range = MultiBufferOffset(start)..MultiBufferOffset(end);- let expected = snapshot- .range_to_buffer_ranges(range.clone())- .into_iter()- .map(|(buffer, range, _)| (buffer.remote_id(), range, None))- .collect::<Vec<_>>();- let actual = snapshot- .range_to_buffer_ranges_with_deleted_hunks(range.clone())- .map(|(buffer, range, anchor)| (buffer.remote_id(), range, anchor))- .collect::<Vec<_>>();- assert_eq!(actual, expected, "{range:?}");- }- }- }+ assert!(+ !mb_anchor.is_valid(&snapshot),+ "anchor past the last excerpt for its buffer should not be valid"+ );+ });}-#[gpui::test]-fn test_range_to_buffer_ranges_zero_length_at_excerpt_boundary(cx: &mut App) {- let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));- let buffer_2 = cx.new(|cx| Buffer::local("ccc\nddd", cx));+/// The contract between anchor comparison and anchor resolution that every+/// sorted-input consumer relies on (`summaries_for_anchors*`, forward-only+/// cursors, and persistent trees ordered by anchor comparison such as the+/// editor's fold tree):+///+/// 1. Within one snapshot, comparison tracks resolution: if `a.cmp(b)` is+/// `Less`, `a` must not resolve after `b`, and anchors that compare+/// `Equal` must resolve to the same offset.+/// 2. Across structural changes (edits, diff base text changes, a path key+/// reused for a different buffer, buffers leaving), a pair's comparison+/// never inverts: `Less` may weaken to `Equal`, but must not become+/// `Greater`. (Even the collapse to `Equal` is hazardous for consumers+/// that sort ranges with end tie-breaks, but it is tolerated here so+/// that outright inversions stay visible.)+///+/// Shrinking yields a minimal operation sequence for whichever violating+/// mechanism it finds. Mechanisms found so far, each fixed and pinned by a+/// distilled test:+/// - stale-path anchors sorted by buffer id but resolved to the end of+/// their path's region+/// (`test_stale_path_anchor_comparison_tracks_resolution`);+/// - diff base anchors' validity filter flipping comparison results when a+/// base text edit deleted the region one anchor of a pair pointed into+/// (`test_folds_stay_sorted_when_diff_base_text_replaced` in the+/// editor's block_map tests);+/// - plain anchors resolved before phantom deleted-hunk rows they compare+/// after (`test_collapsed_plain_anchor_resolves_past_deleted_hunk_rows`).+#[gpui::property_test(config = proptest::prelude::ProptestConfig {+ failure_persistence: Some(Box::new(+ proptest::test_runner::FileFailurePersistence::WithSource("proptest-regressions"),+ )),+ ..Default::default()+})]+async fn test_anchor_comparison_tracks_resolution(+ cx: &mut TestAppContext,+ #[strategy = proptest::collection::vec(proptest::prelude::any::<AnchorContractOp>(), 1..16)]+ ops: Vec<AnchorContractOp>,+) {+ let base_text_variants = [+ "DEL1\nDEL2\nbbb\nccc\nddd\n",+ "DEL1\nbbb\nccc\nddd\n",+ "DEL2\nbbb\nccc\nddd\n",+ "bbb\nccc\nddd\n",+ ];- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+ let mut buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));+ let mut diff_a = cx.new(|cx| {+ BufferDiff::new_with_base_text(+ base_text_variants[0],+ &buffer_a.read(cx).text_snapshot(),+ cx,+ )+ });+ let buffer_b = cx.new(|cx| Buffer::local("xxx\nyyy\n", cx));+ let multibuffer = cx.new(|cx| {+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);+ // Diff views expand all hunks, which materializes deleted rows from+ // the base text and gives anchors in those rows `diff_base_anchor`s.+ multibuffer.set_all_diff_hunks_expanded(cx);+ multibuffer+ });multibuffer.update(cx, |multibuffer, cx| {+ let max_point_a = buffer_a.read(cx).max_point();+ let max_point_b = buffer_b.read(cx).max_point();multibuffer.set_excerpts_for_path(PathKey::sorted(0),- buffer_1.clone(),- [Point::new(0, 0)..Point::new(1, 3)],+ buffer_a.clone(),+ [Point::zero()..max_point_a],0,cx,);multibuffer.set_excerpts_for_path(PathKey::sorted(1),- buffer_2.clone(),- [Point::new(0, 0)..Point::new(1, 3)],- 0,- cx,- );- });-- let snapshot = multibuffer.read(cx).snapshot(cx);- assert_eq!(snapshot.text(), "aaa\nbbb\nccc\nddd");-- // This point is right at the start of the very first excerpt, so if we get- // a buffer range, we should get `0..0`- let excerpt_2_start = Point::new(2, 0);- let expected_ranges = vec![BufferOffset(0)..BufferOffset(0)];- let ranges = snapshot- .range_to_buffer_ranges(excerpt_2_start..excerpt_2_start)- .into_iter()- .map(|tup| tup.1)- .collect_vec();-- assert_eq!(- ranges, expected_ranges,- "Zero-length range at excerpt boundary should return the excerpt at that point"- );-}--#[gpui::test]-async fn test_buffer_range_to_excerpt_ranges(cx: &mut TestAppContext) {- let base_text = indoc!(- "- aaa- bbb- ccc- ddd- eee- ppp- qqq- rrr- fff- ggg- hhh- "- );- let text = indoc!(- "- aaa- BBB- ddd- eee- ppp- qqq- rrr- FFF- ggg- hhh- "- );-- let buffer = cx.new(|cx| Buffer::local(text, cx));- let diff = cx- .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));- cx.run_until_parked();-- let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer.clone(),- [- Point::new(0, 0)..Point::new(3, 3),- Point::new(7, 0)..Point::new(9, 3),- ],+ buffer_b.clone(),+ [Point::zero()..max_point_b],0,cx,);- multibuffer.add_diff(diff.clone(), cx);- multibuffer- });-- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);+ multibuffer.add_diff(diff_a.clone(), cx);});cx.run_until_parked();- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ let mut anchors: Vec<Anchor> = Vec::new();+ let mut previous_orderings: std::collections::HashMap<(usize, usize), cmp::Ordering> =+ Default::default();+ let mut buffer_b_present = true;+ let mut departed_diffs: Vec<Entity<BufferDiff>> = Vec::new();- let actual_diff = format_diff(- &snapshot.text(),- &snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),- &Default::default(),- None,- );- let expected_diff = indoc!(- "- aaa- - bbb- - ccc- + BBB- ddd- eee [\u{2193}]- - fff [\u{2191}]- + FFF- ggg- hhh [\u{2193}]"- );- pretty_assertions::assert_eq!(actual_diff, expected_diff);-- let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());-- let query_spanning_deleted_hunk = buffer_snapshot.anchor_after(Point::new(0, 0))- ..buffer_snapshot.anchor_before(Point::new(1, 3));- assert_eq!(- snapshot- .buffer_range_to_excerpt_ranges(query_spanning_deleted_hunk)- .map(|range| range.to_point(&snapshot))- .collect::<Vec<_>>(),- vec![- Point::new(0, 0)..Point::new(1, 0),- Point::new(3, 0)..Point::new(3, 3),- ],- );+ for (step, op) in ops.iter().enumerate() {+ match op {+ AnchorContractOp::CreateAnchor {+ position,+ left_bias,+ } => {+ let snapshot =+ multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ let offset = MultiBufferOffset(snapshot.len().0 * (*position as usize) / 1000);+ let bias = if *left_bias { Bias::Left } else { Bias::Right };+ anchors.push(snapshot.anchor_at(offset, bias));+ }+ AnchorContractOp::EditBuffer { position, insert } => {+ buffer_a.update(cx, |buffer, cx| {+ let offset = buffer.len() * (*position as usize) / 1000;+ if *insert || buffer.len() == 0 {+ buffer.edit([(offset..offset, "Q\n")], None, cx);+ } else {+ let end = (offset + 1).min(buffer.len());+ buffer.edit([(offset..end, "")], None, cx);+ }+ });+ }+ AnchorContractOp::ChangeBaseText { variant } => {+ let buffer_a_text_snapshot =+ buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());+ diff_a+ .update(cx, |diff, cx| {+ diff.set_base_text(+ Some(base_text_variants[*variant].into()),+ buffer_a_text_snapshot,+ cx,+ )+ })+ .await;+ }+ AnchorContractOp::RekeyPath => {+ buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));+ diff_a = cx.new(|cx| {+ BufferDiff::new_with_base_text(+ base_text_variants[0],+ &buffer_a.read(cx).text_snapshot(),+ cx,+ )+ });+ // Departed diffs belong to the departed buffer; reinstalling+ // them would no longer exercise base buffer swaps.+ departed_diffs.clear();+ multibuffer.update(cx, |multibuffer, cx| {+ let max_point = buffer_a.read(cx).max_point();+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(0),+ buffer_a.clone(),+ [Point::zero()..max_point],+ 0,+ cx,+ );+ multibuffer.add_diff(diff_a.clone(), cx);+ });+ }+ AnchorContractOp::SwapDiff { reinstall, variant } => {+ let buffer_a_text_snapshot =+ buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());+ let next_diff = if *reinstall && let Some(previous_diff) = departed_diffs.pop() {+ // Recompute the reinstalled diff against the buffer's+ // current text; its base text buffer (and so the buffer+ // id anchors compare by) is preserved.+ let base_text = previous_diff+ .read_with(cx, |diff, cx| diff.base_text_string(cx))+ .map(Arc::from);+ previous_diff+ .update(cx, |diff, cx| {+ diff.set_base_text(base_text, buffer_a_text_snapshot, cx)+ })+ .await;+ previous_diff+ } else {+ cx.new(|cx| {+ BufferDiff::new_with_base_text(+ base_text_variants[*variant],+ &buffer_a_text_snapshot,+ cx,+ )+ })+ };+ departed_diffs.push(std::mem::replace(&mut diff_a, next_diff));+ multibuffer.update(cx, |multibuffer, cx| {+ multibuffer.add_diff(diff_a.clone(), cx);+ });+ }+ AnchorContractOp::BiasAnchor { index, right } => {+ if !anchors.is_empty() {+ let snapshot =+ multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ let k = (anchors.len() * (*index as usize) / 1001).min(anchors.len() - 1);+ let rebiased = if *right {+ anchors[k].bias_right(&snapshot)+ } else {+ anchors[k].bias_left(&snapshot)+ };+ anchors.push(rebiased);+ }+ }+ AnchorContractOp::ToggleSecondBuffer => {+ multibuffer.update(cx, |multibuffer, cx| {+ if buffer_b_present {+ multibuffer.remove_excerpts_for_buffer(buffer_b.read(cx).remote_id(), cx);+ } else {+ let max_point = buffer_b.read(cx).max_point();+ multibuffer.set_excerpts_for_path(+ PathKey::sorted(1),+ buffer_b.clone(),+ [Point::zero()..max_point],+ 0,+ cx,+ );+ }+ });+ buffer_b_present = !buffer_b_present;+ }+ }+ cx.run_until_parked();- let query_within_contiguous_main_buffer = buffer_snapshot.anchor_after(Point::new(1, 0))- ..buffer_snapshot.anchor_before(Point::new(2, 3));- assert_eq!(- snapshot- .buffer_range_to_excerpt_ranges(query_within_contiguous_main_buffer)- .map(|range| range.to_point(&snapshot))- .collect::<Vec<_>>(),- vec![Point::new(3, 0)..Point::new(4, 3)],- );+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ for i in 0..anchors.len() {+ for j in i + 1..anchors.len() {+ let ordering = anchors[i].cmp(&anchors[j], &snapshot);+ let offset_i = anchors[i].to_offset(&snapshot);+ let offset_j = anchors[j].to_offset(&snapshot);+ let resolution_consistent = match ordering {+ cmp::Ordering::Less => offset_i <= offset_j,+ cmp::Ordering::Equal => offset_i == offset_j,+ cmp::Ordering::Greater => offset_i >= offset_j,+ };+ assert!(+ resolution_consistent,+ "after step {step} ({op:?}), comparison contradicts resolution:\n\+ anchor {i}: {:?}\n resolves to {offset_i:?}\n\+ anchor {j}: {:?}\n resolves to {offset_j:?}\n\+ but compares {ordering:?}",+ anchors[i], anchors[j],+ );- let query_spanning_both_excerpts = buffer_snapshot.anchor_after(Point::new(2, 0))- ..buffer_snapshot.anchor_before(Point::new(8, 3));- assert_eq!(- snapshot- .buffer_range_to_excerpt_ranges(query_spanning_both_excerpts)- .map(|range| range.to_point(&snapshot))- .collect::<Vec<_>>(),- vec![- Point::new(4, 0)..Point::new(5, 3),- Point::new(7, 0)..Point::new(8, 3),- ],- );+ if let Some(previous) = previous_orderings.insert((i, j), ordering) {+ let inverted = matches!(+ (previous, ordering),+ (cmp::Ordering::Less, cmp::Ordering::Greater)+ | (cmp::Ordering::Greater, cmp::Ordering::Less)+ );+ assert!(+ !inverted,+ "after step {step} ({op:?}), comparison inverted over time:\n\+ anchor {i}: {:?}\n\+ anchor {j}: {:?}\n\+ compared {previous:?} before this step, {ordering:?} after",+ anchors[i], anchors[j],+ );+ }+ }+ }+ }}+/// Distilled from `test_anchor_comparison_tracks_resolution`'s minimal+/// shrunk counterexample (create anchor, re-key the path, create anchor).+/// After a path key is reused for a different buffer, an anchor into the+/// departed buffer sorts against anchors into the new buffer by buffer id,+/// so resolution must land it on the matching side of the path's region:+/// the start when the departed buffer's id is lower than the current+/// occupant's, the end otherwise. When resolution instead ignored that+/// order (it always chose the end), sorted-input consumers feeding+/// comparison-sorted anchors to forward-only cursors walked backward in+/// offset space — the "cannot seek backward" crash family (e.g. ZED-95K).#[gpui::test]-fn test_cannot_seek_backward_after_excerpt_replacement(cx: &mut TestAppContext) {- let buffer_b_text: String = (0..50).map(|i| format!("line_b {i}\n")).collect();- let buffer_b = cx.new(|cx| Buffer::local(buffer_b_text, cx));-- let buffer_c_text: String = (0..10).map(|i| format!("line_c {i}\n")).collect();- let buffer_c = cx.new(|cx| Buffer::local(buffer_c_text, cx));-- let buffer_d_text: String = (0..10).map(|i| format!("line_d {i}\n")).collect();- let buffer_d = cx.new(|cx| Buffer::local(buffer_d_text, cx));-- let path_b = PathKey::with_sort_prefix(0, rel_path("bbb.rs").into_arc());- let path_c = PathKey::with_sort_prefix(0, rel_path("ddd.rs").into_arc());- let path_d = PathKey::with_sort_prefix(0, rel_path("ccc.rs").into_arc());-+async fn test_stale_path_anchor_comparison_tracks_resolution(cx: &mut TestAppContext) {+ let old_buffer = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));-multibuffer.update(cx, |multibuffer, cx| {+ let max_point = old_buffer.read(cx).max_point();multibuffer.set_excerpts_for_path(- path_b.clone(),- buffer_b.clone(),- vec![- Point::row_range(0..3),- Point::row_range(15..18),- Point::row_range(30..33),- ],+ PathKey::sorted(0),+ old_buffer.clone(),+ [Point::zero()..max_point],0,cx,);});+ let stale = multibuffer.read_with(cx, |multibuffer, cx| {+ multibuffer+ .snapshot(cx)+ .anchor_at(MultiBufferOffset(0), Bias::Right)+ });+ let new_buffer = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));multibuffer.update(cx, |multibuffer, cx| {+ let max_point = new_buffer.read(cx).max_point();multibuffer.set_excerpts_for_path(- path_c.clone(),- buffer_c.clone(),- vec![Point::row_range(0..3)],+ PathKey::sorted(0),+ new_buffer.clone(),+ [Point::zero()..max_point],0,cx,);});+ cx.run_until_parked();- let (anchor_in_e_b2, anchor_in_e_b3) = multibuffer.read_with(cx, |multibuffer, cx| {- let snapshot = multibuffer.snapshot(cx);- let excerpt_infos = snapshot.excerpts().collect::<Vec<_>>();- assert_eq!(excerpt_infos.len(), 4, "expected 4 excerpts (3×B + 1×C)");-- let e_b2_info = excerpt_infos[1].clone();- let e_b3_info = excerpt_infos[2].clone();+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ let fresh = snapshot.anchor_at(MultiBufferOffset(0), Bias::Right);- let anchor_b2 = snapshot.anchor_in_excerpt(e_b2_info.context.start).unwrap();- let anchor_b3 = snapshot.anchor_in_excerpt(e_b3_info.context.start).unwrap();- (anchor_b2, anchor_b3)- });+ let ordering = stale.cmp(&fresh, &snapshot);+ let stale_offset = stale.to_offset(&snapshot);+ let fresh_offset = fresh.to_offset(&snapshot);+ let resolution_consistent = match ordering {+ cmp::Ordering::Less => stale_offset <= fresh_offset,+ cmp::Ordering::Equal => stale_offset == fresh_offset,+ cmp::Ordering::Greater => stale_offset >= fresh_offset,+ };+ assert!(+ resolution_consistent,+ "stale anchor {stale:?} resolves to {stale_offset:?} and fresh anchor {fresh:?} \+ resolves to {fresh_offset:?}, but they compare {ordering:?}"+ );+}- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_excerpts_for_path(- path_b.clone(),- buffer_b.clone(),- vec![Point::row_range(0..3), Point::row_range(28..36)],- 0,- cx,- );+/// Distilled from `test_anchor_comparison_tracks_resolution`'s second+/// shrunk counterexample. An expanded deleted hunk's phantom rows occupy+/// its attachment anchor's tie space in the buffer's CRDT order: anchor+/// comparison places a plain buffer anchor after the hunk's rows exactly+/// when it sorts past the attachment anchor, which can only happen once+/// the buffer text separating them has been deleted. Resolution must+/// place the anchor on the same side. It used to depend on which+/// transform the walk's cursor rested on: arriving on the deleted hunk+/// itself applied the CRDT rule, but arriving on the preceding buffer+/// content returned early, parking the anchor before rows it compares+/// after — so `to_offset` and a shared-cursor `summaries_for_anchors`+/// disagreed about the same anchor, and comparison-sorted consumers fed+/// forward-only cursors positions that moved backward.+#[gpui::test]+async fn test_collapsed_plain_anchor_resolves_past_deleted_hunk_rows(cx: &mut TestAppContext) {+ let base_text = "DEL1\nDEL2\nbbb\nccc\nddd\n";+ let buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));+ let diff_a = cx.new(|cx| {+ BufferDiff::new_with_base_text(base_text, &buffer_a.read(cx).text_snapshot(), cx)+ });+ let multibuffer = cx.new(|cx| {+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);+ multibuffer.set_all_diff_hunks_expanded(cx);+ multibuffer});-multibuffer.update(cx, |multibuffer, cx| {+ let max_point_a = buffer_a.read(cx).max_point();multibuffer.set_excerpts_for_path(- path_d.clone(),- buffer_d.clone(),- vec![Point::row_range(0..3)],+ PathKey::sorted(0),+ buffer_a.clone(),+ [Point::zero()..max_point_a],0,cx,);+ multibuffer.add_diff(diff_a.clone(), cx);});+ cx.run_until_parked();- multibuffer.read_with(cx, |multibuffer, cx| {- let snapshot = multibuffer.snapshot(cx);- snapshot.summaries_for_anchors::<Point, _>(&[anchor_in_e_b2, anchor_in_e_b3]);- });-}--#[gpui::test]-fn test_resolving_max_anchor_for_buffer(cx: &mut TestAppContext) {- let dock_base_text = indoc! {"- 0- 1- 2- 3- 4- 5- 6- 7- 8- 9- 10- 11- 12- "};-- let dock_text = indoc! {"- 0- 4- 5- 6- 10- 11- 12- "};-- let dock_buffer = cx.new(|cx| Buffer::local(dock_text, cx));- let diff = cx.new(|cx| {- BufferDiff::new_with_base_text(dock_base_text, &dock_buffer.read(cx).snapshot(), cx)+ // Delete the first "d" (insertion offset 8), then anchor before the last+ // "d" (insertion offset 10).+ buffer_a.update(cx, |buffer, cx| {+ buffer.edit([(8..9, "")], None, cx);});+ cx.run_until_parked();+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\ndd\n");+ let plain_anchor = snapshot.anchor_at(MultiBufferOffset(19), Bias::Left);- let workspace_text = "second buffer\n";- let workspace_buffer = cx.new(|cx| Buffer::local(workspace_text, cx));-- let dock_path = PathKey::with_sort_prefix(0, rel_path("").into_arc());- let workspace_path = PathKey::with_sort_prefix(1, rel_path("").into_arc());+ // Recompute the diff against the edited buffer: a "-ddd/+dd" hunk+ // appears, attached at the buffer position both anchors will collapse+ // to. Anchor one character into its phantom "ddd" row.+ let buffer_a_text_snapshot = buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());+ diff_a+ .update(cx, |diff, cx| {+ diff.set_base_text(Some(base_text.into()), buffer_a_text_snapshot, cx)+ })+ .await;+ cx.run_until_parked();+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\nddd\ndd\n");+ let hunk_anchor = snapshot.anchor_at(MultiBufferOffset(19), Bias::Right);- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+ assert_eq!(+ plain_anchor.cmp(&hunk_anchor, &snapshot),+ cmp::Ordering::Greater+ );+ assert_eq!(plain_anchor.to_offset(&snapshot), MultiBufferOffset(23));+ assert_eq!(hunk_anchor.to_offset(&snapshot), MultiBufferOffset(19));- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_excerpt_ranges_for_path(- dock_path,- dock_buffer.clone(),- &dock_buffer.read(cx).snapshot(),- vec![- ExcerptRange::new(Point::zero()..Point::new(1, 1)),- ExcerptRange::new(Point::new(3, 0)..Point::new(4, 2)),- ],- cx,- );- multibuffer.set_excerpt_ranges_for_path(- workspace_path,- workspace_buffer.clone(),- &workspace_buffer.read(cx).snapshot(),- vec![ExcerptRange::new(- Point::zero()..workspace_buffer.read(cx).max_point(),- )],- cx,- );- multibuffer.add_diff(diff, cx);- multibuffer.set_all_diff_hunks_expanded(cx);+ // Delete the "d" separating the two anchors (insertion offset 9). Their+ // text anchors now both collapse to the seam where the phantom row+ // hangs, and only the CRDT order remembers which side of it each+ // belongs on.+ buffer_a.update(cx, |buffer, cx| {+ buffer.edit([(8..9, "")], None, cx);});+ cx.run_until_parked();+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\nddd\nd\n");- let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));- let diff = format_diff(- &snapshot.text(),- &snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),- &Default::default(),- None,+ assert_eq!(+ plain_anchor.cmp(&hunk_anchor, &snapshot),+ cmp::Ordering::Greater,+ "comparison must not change: the buffer order of the anchors is immutable");assert_eq!(- diff,- indoc! {"- 0- - 1- - 2- - 3- 4 [↓]- 6 [↑]- - 7- - 8- - 9- 10 [↓]- second buffer- "}+ hunk_anchor.to_offset(&snapshot),+ MultiBufferOffset(19),+ "the hunk-interior anchor stays one character into the phantom row"+ );+ assert_eq!(+ plain_anchor.to_offset(&snapshot),+ MultiBufferOffset(22),+ "the plain anchor sorts past the hunk's attachment anchor, so it must \+ resolve past the phantom rows"+ );+ assert_eq!(+ snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&[hunk_anchor, plain_anchor]),+ vec![MultiBufferOffset(19), MultiBufferOffset(22)],+ "the shared-cursor batch path must agree with individual resolution");+}- multibuffer.update(cx, |multibuffer, cx| {- let snapshot = multibuffer.snapshot(cx);- let point = snapshot- .anchor_in_buffer(text::Anchor::max_for_buffer(- dock_buffer.read(cx).remote_id(),- ))- .unwrap()- .to_point(&snapshot);- assert_eq!(point, Point::new(10, 0));- })+#[ctor::ctor(unsafe)]+fn init_logger() {+ zlog::init_test();}-#[gpui::test]-fn test_is_valid_anchor_past_last_excerpt_for_buffer(cx: &mut TestAppContext) {- let buffer_a = cx.new(|cx| Buffer::local("aaa\nbbb\nccc\n", cx));- buffer_a.update(cx, |buffer, cx| {- let len = buffer.len();- buffer.edit([(len..len, "ddd\neee\n")], None, cx);- });- let buffer_b = cx.new(|cx| Buffer::local("xxx\n", cx));- for line in ["yyy\n", "zzz\n", "www\n", "vvv\n"] {- buffer_b.update(cx, |buffer, cx| {- let len = buffer.len();- buffer.edit([(len..len, line)], None, cx);- });- }+/// A naive implementation of a multi-buffer that does not maintain+/// any derived state, used for comparison in a randomized test.+#[derive(Default)]+struct ReferenceMultibuffer {+ excerpts: Vec<ReferenceExcerpt>,+ diffs: HashMap<BufferId, Entity<BufferDiff>>,+ inverted_diffs: HashMap<BufferId, (Entity<BufferDiff>, Entity<language::Buffer>)>,+ expanded_diff_hunks_by_buffer: HashMap<BufferId, Vec<text::Anchor>>,+}- let path_a = PathKey::with_sort_prefix(0, rel_path("aaa.rs").into_arc());- let path_b = PathKey::with_sort_prefix(1, rel_path("bbb.rs").into_arc());+#[derive(Clone, Debug)]+struct ReferenceExcerpt {+ path_key: PathKey,+ path_key_index: PathKeyIndex,+ buffer: Entity<Buffer>,+ range: Range<text::Anchor>,+}- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));+#[derive(Clone, Debug)]+struct ReferenceRegion {+ buffer_id: Option<BufferId>,+ range: Range<usize>,+ buffer_range: Range<Point>,+ // if this is a deleted hunk, the main buffer anchor to which the deleted content is attached+ deleted_hunk_anchor: Option<text::Anchor>,+ status: Option<DiffHunkStatus>,+ excerpt: Option<ReferenceExcerpt>,+}- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.set_excerpts_for_path(- path_a.clone(),- buffer_a.clone(),- vec![Point::new(1, 0)..Point::new(2, 3)],- 0,- cx,- );- multibuffer.set_excerpts_for_path(- path_b.clone(),- buffer_b.clone(),- vec![Point::new(1, 0)..Point::new(3, 3)],- 0,- cx,- );- });+impl ReferenceMultibuffer {+ fn expand_excerpts(+ &mut self,+ excerpts: &HashSet<ExcerptRange<text::Anchor>>,+ line_count: u32,+ cx: &mut App,+ ) {+ use text::AnchorRangeExt as _;- multibuffer.read_with(cx, |multibuffer, cx| {- let snapshot = multibuffer.snapshot(cx);+ if line_count == 0 || excerpts.is_empty() {+ return;+ }- let buffer_a_snapshot = buffer_a.read(cx).snapshot();- let anchor_past_excerpt = buffer_a_snapshot.anchor_after(Point::new(4, 0));- let mb_anchor = snapshot.anchor_in_buffer(anchor_past_excerpt).unwrap();+ let mut excerpts_by_buffer: HashMap<BufferId, Vec<ExcerptRange<text::Anchor>>> =+ HashMap::default();+ for excerpt in excerpts {+ excerpts_by_buffer+ .entry(excerpt.context.start.buffer_id)+ .or_default()+ .push(excerpt.clone())+ }- assert!(- !mb_anchor.is_valid(&snapshot),- "anchor past the last excerpt for its buffer should not be valid"- );- });-}+ for (buffer_id, excerpts_to_expand) in excerpts_by_buffer {+ let mut buffer = None;+ let mut buffer_snapshot = None;+ let mut path = None;+ let mut path_key_index = None;+ let mut new_ranges =+ self.excerpts+ .iter()+ .filter(|excerpt| excerpt.range.start.buffer_id == buffer_id)+ .map(|excerpt| {+ let snapshot = excerpt.buffer.read(cx).snapshot();+ let mut range = excerpt.range.to_point(&snapshot);+ if excerpts_to_expand.iter().any(|info| {+ excerpt.range.contains_anchor(info.context.start, &snapshot)+ }) {+ range.start = Point::new(range.start.row.saturating_sub(line_count), 0);+ range.end = snapshot+ .clip_point(Point::new(range.end.row + line_count, 0), Bias::Left);+ range.end.column = snapshot.line_len(range.end.row);+ }+ buffer = Some(excerpt.buffer.clone());+ buffer_snapshot = Some(snapshot);+ path = Some(excerpt.path_key.clone());+ path_key_index = Some(excerpt.path_key_index);+ ExcerptRange::new(range)+ })+ .collect::<Vec<_>>();-/// The contract between anchor comparison and anchor resolution that every-/// sorted-input consumer relies on (`summaries_for_anchors*`, forward-only-/// cursors, and persistent trees ordered by anchor comparison such as the-/// editor's fold tree):-///-/// 1. Within one snapshot, comparison tracks resolution: if `a.cmp(b)` is-/// `Less`, `a` must not resolve after `b`, and anchors that compare-/// `Equal` must resolve to the same offset.-/// 2. Across structural changes (edits, diff base text changes, a path key-/// reused for a different buffer, buffers leaving), a pair's comparison-/// never inverts: `Less` may weaken to `Equal`, but must not become-/// `Greater`. (Even the collapse to `Equal` is hazardous for consumers-/// that sort ranges with end tie-breaks, but it is tolerated here so-/// that outright inversions stay visible.)-///-/// Shrinking yields a minimal operation sequence for whichever violating-/// mechanism it finds. Mechanisms found so far, each fixed and pinned by a-/// distilled test:-/// - stale-path anchors sorted by buffer id but resolved to the end of-/// their path's region-/// (`test_stale_path_anchor_comparison_tracks_resolution`);-/// - diff base anchors' validity filter flipping comparison results when a-/// base text edit deleted the region one anchor of a pair pointed into-/// (`test_folds_stay_sorted_when_diff_base_text_replaced` in the-/// editor's block_map tests);-/// - plain anchors resolved before phantom deleted-hunk rows they compare-/// after (`test_collapsed_plain_anchor_resolves_past_deleted_hunk_rows`).-#[gpui::property_test(config = proptest::prelude::ProptestConfig {- failure_persistence: Some(Box::new(- proptest::test_runner::FileFailurePersistence::WithSource("proptest-regressions"),- )),- ..Default::default()-})]-async fn test_anchor_comparison_tracks_resolution(- cx: &mut TestAppContext,- #[strategy = proptest::collection::vec(proptest::prelude::any::<AnchorContractOp>(), 1..16)]- ops: Vec<AnchorContractOp>,-) {- let base_text_variants = [- "DEL1\nDEL2\nbbb\nccc\nddd\n",- "DEL1\nbbb\nccc\nddd\n",- "DEL2\nbbb\nccc\nddd\n",- "bbb\nccc\nddd\n",- ];+ new_ranges.sort_by_key(|nr| nr.context.start);- let mut buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));- let mut diff_a = cx.new(|cx| {- BufferDiff::new_with_base_text(- base_text_variants[0],- &buffer_a.read(cx).text_snapshot(),- cx,- )- });- let buffer_b = cx.new(|cx| Buffer::local("xxx\nyyy\n", cx));- let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);- // Diff views expand all hunks, which materializes deleted rows from- // the base text and gives anchors in those rows `diff_base_anchor`s.- multibuffer.set_all_diff_hunks_expanded(cx);- multibuffer- });- multibuffer.update(cx, |multibuffer, cx| {- let max_point_a = buffer_a.read(cx).max_point();- let max_point_b = buffer_b.read(cx).max_point();- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_a.clone(),- [Point::zero()..max_point_a],- 0,- cx,- );- multibuffer.set_excerpts_for_path(- PathKey::sorted(1),- buffer_b.clone(),- [Point::zero()..max_point_b],- 0,- cx,+ self.set_excerpts(+ path.unwrap(),+ path_key_index.unwrap(),+ buffer.unwrap(),+ &buffer_snapshot.unwrap(),+ new_ranges,+ cx,+ );+ }+ }++ fn set_excerpts(+ &mut self,+ path_key: PathKey,+ path_key_index: PathKeyIndex,+ buffer: Entity<Buffer>,+ buffer_snapshot: &BufferSnapshot,+ ranges: Vec<ExcerptRange<Point>>,+ cx: &mut App,+ ) {+ self.excerpts.retain(|excerpt| {+ excerpt.path_key != path_key && excerpt.buffer.entity_id() != buffer.entity_id()+ });++ let ranges = MultiBuffer::merge_excerpt_ranges(&ranges);++ let (Ok(ix) | Err(ix)) = self+ .excerpts+ .binary_search_by(|probe| probe.path_key.cmp(&path_key));+ self.excerpts.splice(+ ix..ix,+ ranges.into_iter().map(|range| ReferenceExcerpt {+ path_key: path_key.clone(),+ path_key_index,+ buffer: buffer.clone(),+ range: buffer_snapshot.anchor_before(range.context.start)+ ..buffer_snapshot.anchor_after(range.context.end),+ }),);- multibuffer.add_diff(diff_a.clone(), cx);- });- cx.run_until_parked();+ self.update_expanded_diff_hunks_for_buffer(buffer_snapshot.remote_id(), cx);+ }- let mut anchors: Vec<Anchor> = Vec::new();- let mut previous_orderings: std::collections::HashMap<(usize, usize), cmp::Ordering> =- Default::default();- let mut buffer_b_present = true;- let mut departed_diffs: Vec<Entity<BufferDiff>> = Vec::new();+ fn expand_diff_hunks(&mut self, path_key: PathKey, range: Range<text::Anchor>, cx: &App) {+ let excerpt = self+ .excerpts+ .iter_mut()+ .find(|e| {+ e.path_key == path_key+ && e.range+ .start+ .cmp(&range.start, &e.buffer.read(cx).snapshot())+ .is_le()+ && e.range+ .end+ .cmp(&range.end, &e.buffer.read(cx).snapshot())+ .is_ge()+ })+ .unwrap();+ let buffer = excerpt.buffer.read(cx).snapshot();+ let buffer_id = buffer.remote_id();- for (step, op) in ops.iter().enumerate() {- match op {- AnchorContractOp::CreateAnchor {- position,- left_bias,- } => {- let snapshot =- multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- let offset = MultiBufferOffset(snapshot.len().0 * (*position as usize) / 1000);- let bias = if *left_bias { Bias::Left } else { Bias::Right };- anchors.push(snapshot.anchor_at(offset, bias));+ // Skip inverted excerpts - hunks are always expanded+ if self.inverted_diffs.contains_key(&buffer_id) {+ return;+ }++ let Some(diff) = self.diffs.get(&buffer_id) else {+ return;+ };+ let excerpt_range = excerpt.range.to_point(&buffer);+ let expanded_diff_hunks = self+ .expanded_diff_hunks_by_buffer+ .entry(buffer_id)+ .or_default();+ for hunk in diff+ .read(cx)+ .snapshot(cx)+ .hunks_intersecting_range(range, &buffer)+ {+ let hunk_range = hunk.buffer_range.to_point(&buffer);+ if hunk_range.start < excerpt_range.start || hunk_range.start > excerpt_range.end {+ continue;}- AnchorContractOp::EditBuffer { position, insert } => {- buffer_a.update(cx, |buffer, cx| {- let offset = buffer.len() * (*position as usize) / 1000;- if *insert || buffer.len() == 0 {- buffer.edit([(offset..offset, "Q\n")], None, cx);- } else {- let end = (offset + 1).min(buffer.len());- buffer.edit([(offset..end, "")], None, cx);- }- });- }- AnchorContractOp::ChangeBaseText { variant } => {- let buffer_a_text_snapshot =- buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());- diff_a- .update(cx, |diff, cx| {- diff.set_base_text(- Some(base_text_variants[*variant].into()),- buffer_a_text_snapshot,- cx,- )- })- .await;+ if let Err(ix) = expanded_diff_hunks+ .binary_search_by(|anchor| anchor.cmp(&hunk.buffer_range.start, &buffer))+ {+ log::info!(+ "expanding diff hunk {:?}. excerpt range: {:?}, buffer {:?}",+ hunk_range,+ excerpt_range,+ buffer.remote_id()+ );+ expanded_diff_hunks.insert(ix, hunk.buffer_range.start);+ } else {+ log::trace!("hunk {hunk_range:?} already expanded in excerpt");}- AnchorContractOp::RekeyPath => {- buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));- diff_a = cx.new(|cx| {- BufferDiff::new_with_base_text(- base_text_variants[0],- &buffer_a.read(cx).text_snapshot(),- cx,- )- });- // Departed diffs belong to the departed buffer; reinstalling- // them would no longer exercise base buffer swaps.- departed_diffs.clear();- multibuffer.update(cx, |multibuffer, cx| {- let max_point = buffer_a.read(cx).max_point();- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_a.clone(),- [Point::zero()..max_point],- 0,- cx,- );- multibuffer.add_diff(diff_a.clone(), cx);+ }+ }++ fn expected_content(+ &self,+ cx: &App,+ ) -> (+ String,+ Vec<RowInfo>,+ HashSet<MultiBufferRow>,+ Vec<ReferenceRegion>,+ ) {+ use util::maybe;++ let mut text = String::new();+ let mut regions = Vec::<ReferenceRegion>::new();+ let mut excerpt_boundary_rows = HashSet::default();+ for excerpt in &self.excerpts {+ excerpt_boundary_rows.insert(MultiBufferRow(text.matches('\n').count() as u32));+ let buffer = excerpt.buffer.read(cx);+ let buffer_id = buffer.remote_id();+ let buffer_range = excerpt.range.to_offset(buffer);++ if let Some((diff, main_buffer)) = self.inverted_diffs.get(&buffer_id) {+ let diff_snapshot = diff.read(cx).snapshot(cx);+ let main_buffer_snapshot = main_buffer.read(cx).snapshot();++ let mut offset = buffer_range.start;+ for hunk in diff_snapshot.hunks_intersecting_base_text_range(+ buffer_range.clone(),+ &main_buffer_snapshot.text,+ ) {+ let mut hunk_base_range = hunk.diff_base_byte_range.clone();++ hunk_base_range.end = hunk_base_range.end.min(buffer_range.end);+ if hunk_base_range.start > buffer_range.end+ || hunk_base_range.start < buffer_range.start+ {+ continue;+ }++ // Add the text before the hunk+ if hunk_base_range.start >= offset {+ let len = text.len();+ text.extend(buffer.text_for_range(offset..hunk_base_range.start));+ if text.len() > len {+ regions.push(ReferenceRegion {+ buffer_id: Some(buffer_id),+ range: len..text.len(),+ buffer_range: (offset..hunk_base_range.start).to_point(&buffer),+ status: None,+ excerpt: Some(excerpt.clone()),+ deleted_hunk_anchor: None,+ });+ }+ }++ // Add the "deleted" region (base text that's not in main)+ if !hunk_base_range.is_empty() {+ let len = text.len();+ text.extend(buffer.text_for_range(hunk_base_range.clone()));+ regions.push(ReferenceRegion {+ buffer_id: Some(buffer_id),+ range: len..text.len(),+ buffer_range: hunk_base_range.to_point(&buffer),+ status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),+ excerpt: Some(excerpt.clone()),+ deleted_hunk_anchor: None,+ });+ }++ offset = hunk_base_range.end;+ }++ // Add remaining buffer text+ let len = text.len();+ text.extend(buffer.text_for_range(offset..buffer_range.end));+ text.push('\n');+ regions.push(ReferenceRegion {+ buffer_id: Some(buffer_id),+ range: len..text.len(),+ buffer_range: (offset..buffer_range.end).to_point(&buffer),+ status: None,+ excerpt: Some(excerpt.clone()),+ deleted_hunk_anchor: None,});- }- AnchorContractOp::SwapDiff { reinstall, variant } => {- let buffer_a_text_snapshot =- buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());- let next_diff = if *reinstall && let Some(previous_diff) = departed_diffs.pop() {- // Recompute the reinstalled diff against the buffer's- // current text; its base text buffer (and so the buffer- // id anchors compare by) is preserved.- let base_text = previous_diff- .read_with(cx, |diff, cx| diff.base_text_string(cx))- .map(Arc::from);- previous_diff- .update(cx, |diff, cx| {- diff.set_base_text(base_text, buffer_a_text_snapshot, cx)+ } else {+ let diff = self.diffs.get(&buffer_id).unwrap().read(cx).snapshot(cx);+ let base_buffer = diff.base_text();++ let mut offset = buffer_range.start;+ let hunks = diff+ .hunks_intersecting_range(excerpt.range.clone(), buffer)+ .peekable();++ for hunk in hunks {+ // Ignore hunks that are outside the excerpt range.+ let mut hunk_range = hunk.buffer_range.to_offset(buffer);++ hunk_range.end = hunk_range.end.min(buffer_range.end);+ if hunk_range.start > buffer_range.end || hunk_range.start < buffer_range.start+ {+ log::trace!("skipping hunk outside excerpt range");+ continue;+ }++ if !self+ .expanded_diff_hunks_by_buffer+ .get(&buffer_id)+ .cloned()+ .into_iter()+ .flatten()+ .any(|expanded_anchor| {+ expanded_anchor+ .cmp(&hunk.buffer_range.start, buffer)+ .is_eq()})- .await;- previous_diff- } else {- cx.new(|cx| {- BufferDiff::new_with_base_text(- base_text_variants[*variant],- &buffer_a_text_snapshot,- cx,- )- })- };- departed_diffs.push(std::mem::replace(&mut diff_a, next_diff));- multibuffer.update(cx, |multibuffer, cx| {- multibuffer.add_diff(diff_a.clone(), cx);- });- }- AnchorContractOp::BiasAnchor { index, right } => {- if !anchors.is_empty() {- let snapshot =- multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- let k = (anchors.len() * (*index as usize) / 1001).min(anchors.len() - 1);- let rebiased = if *right {- anchors[k].bias_right(&snapshot)- } else {- anchors[k].bias_left(&snapshot)- };- anchors.push(rebiased);- }- }- AnchorContractOp::ToggleSecondBuffer => {- multibuffer.update(cx, |multibuffer, cx| {- if buffer_b_present {- multibuffer.remove_excerpts_for_buffer(buffer_b.read(cx).remote_id(), cx);- } else {- let max_point = buffer_b.read(cx).max_point();- multibuffer.set_excerpts_for_path(- PathKey::sorted(1),- buffer_b.clone(),- [Point::zero()..max_point],- 0,- cx,- );+ {+ log::trace!("skipping a hunk that's not marked as expanded");+ continue;}- });- buffer_b_present = !buffer_b_present;- }- }- cx.run_until_parked();- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- for i in 0..anchors.len() {- for j in i + 1..anchors.len() {- let ordering = anchors[i].cmp(&anchors[j], &snapshot);- let offset_i = anchors[i].to_offset(&snapshot);- let offset_j = anchors[j].to_offset(&snapshot);- let resolution_consistent = match ordering {- cmp::Ordering::Less => offset_i <= offset_j,- cmp::Ordering::Equal => offset_i == offset_j,- cmp::Ordering::Greater => offset_i >= offset_j,- };+ if !hunk.buffer_range.start.is_valid(buffer) {+ log::trace!("skipping hunk with deleted start: {:?}", hunk.range);+ continue;+ }++ if hunk_range.start >= offset {+ // Add the buffer text before the hunk+ let len = text.len();+ text.extend(buffer.text_for_range(offset..hunk_range.start));+ if text.len() > len {+ regions.push(ReferenceRegion {+ buffer_id: Some(buffer_id),+ range: len..text.len(),+ buffer_range: (offset..hunk_range.start).to_point(&buffer),+ status: None,+ excerpt: Some(excerpt.clone()),+ deleted_hunk_anchor: None,+ });+ }++ // Add the deleted text for the hunk.+ if !hunk.diff_base_byte_range.is_empty() {+ let mut base_text = base_buffer+ .text_for_range(hunk.diff_base_byte_range.clone())+ .collect::<String>();+ if !base_text.ends_with('\n') {+ base_text.push('\n');+ }+ let len = text.len();+ text.push_str(&base_text);+ regions.push(ReferenceRegion {+ buffer_id: Some(base_buffer.remote_id()),+ range: len..text.len(),+ buffer_range: hunk.diff_base_byte_range.to_point(&base_buffer),+ status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),+ excerpt: Some(excerpt.clone()),+ deleted_hunk_anchor: Some(hunk.buffer_range.start),+ });+ }++ offset = hunk_range.start;+ }++ // Add the inserted text for the hunk.+ if hunk_range.end > offset {+ let len = text.len();+ text.extend(buffer.text_for_range(offset..hunk_range.end));+ let range = len..text.len();+ let region = ReferenceRegion {+ buffer_id: Some(buffer_id),+ range,+ buffer_range: (offset..hunk_range.end).to_point(&buffer),+ status: Some(DiffHunkStatus::added(hunk.secondary_status)),+ excerpt: Some(excerpt.clone()),+ deleted_hunk_anchor: None,+ };+ offset = hunk_range.end;+ regions.push(region);+ }+ }++ // Add the buffer text for the rest of the excerpt.+ let len = text.len();+ text.extend(buffer.text_for_range(offset..buffer_range.end));+ text.push('\n');+ regions.push(ReferenceRegion {+ buffer_id: Some(buffer_id),+ range: len..text.len(),+ buffer_range: (offset..buffer_range.end).to_point(&buffer),+ status: None,+ excerpt: Some(excerpt.clone()),+ deleted_hunk_anchor: None,+ });+ }+ }++ // Remove final trailing newline.+ if self.excerpts.is_empty() {+ regions.push(ReferenceRegion {+ buffer_id: None,+ range: 0..1,+ buffer_range: Point::new(0, 0)..Point::new(0, 1),+ status: None,+ excerpt: None,+ deleted_hunk_anchor: None,+ });+ } else {+ text.pop();+ let region = regions.last_mut().unwrap();+ assert!(region.deleted_hunk_anchor.is_none());+ region.range.end -= 1;+ }++ // Retrieve the row info using the region that contains+ // the start of each multi-buffer line.+ let mut ix = 0;+ let row_infos = text+ .split('\n')+ .map(|line| {+ let row_info = regions+ .iter()+ .rposition(|region| {+ region.range.contains(&ix) || (ix == text.len() && ix == region.range.end)+ })+ .map_or(RowInfo::default(), |region_ix| {+ let region = regions[region_ix].clone();+ let buffer_row = region.buffer_range.start.row+ + text[region.range.start..ix].matches('\n').count() as u32;+ let main_buffer = region.excerpt.as_ref().map(|e| e.buffer.clone());+ let excerpt_range = region.excerpt.as_ref().map(|e| &e.range);+ let is_excerpt_start = region_ix == 0+ || regions[region_ix - 1].excerpt.as_ref().map(|e| &e.range)+ != excerpt_range+ || regions[region_ix - 1].range.is_empty();+ let mut is_excerpt_end = region_ix == regions.len() - 1+ || regions[region_ix + 1].excerpt.as_ref().map(|e| &e.range)+ != excerpt_range;+ let is_start = !text[region.range.start..ix].contains('\n');+ let is_last_region = region_ix == regions.len() - 1;+ let mut is_end = if region.range.end > text.len() {+ !text[ix..].contains('\n')+ } else {+ let remaining_newlines = text[ix..region.range.end.min(text.len())]+ .matches('\n')+ .count();+ remaining_newlines == if is_last_region { 0 } else { 1 }+ };+ if region_ix < regions.len() - 1+ && !text[ix..].contains("\n")+ && (region.status == Some(DiffHunkStatus::added_none())+ || region.status.is_some_and(|s| s.is_deleted()))+ && regions[region_ix + 1].excerpt.as_ref().map(|e| &e.range)+ == excerpt_range+ && regions[region_ix + 1].range.start == text.len()+ {+ is_end = true;+ is_excerpt_end = true;+ }+ let multibuffer_row =+ MultiBufferRow(text[..ix].matches('\n').count() as u32);+ let mut expand_direction = None;+ if let Some(buffer) = &main_buffer {+ let needs_expand_up = is_excerpt_start && is_start && buffer_row > 0;+ let needs_expand_down = is_excerpt_end+ && is_end+ && buffer.read(cx).max_point().row > buffer_row;+ expand_direction = if needs_expand_up && needs_expand_down {+ Some(ExpandExcerptDirection::UpAndDown)+ } else if needs_expand_up {+ Some(ExpandExcerptDirection::Up)+ } else if needs_expand_down {+ Some(ExpandExcerptDirection::Down)+ } else {+ None+ };+ }+ RowInfo {+ buffer_id: region.buffer_id,+ diff_status: region.status,+ buffer_row: Some(buffer_row),+ wrapped_buffer_row: None,++ multibuffer_row: Some(multibuffer_row),+ expand_info: maybe!({+ let direction = expand_direction?;+ let excerpt = region.excerpt.as_ref()?;+ Some(ExpandInfo {+ direction,+ start_anchor: Anchor::in_buffer(+ excerpt.path_key_index,+ excerpt.range.start,+ ),+ })+ }),+ }+ });+ ix += line.len() + 1;+ row_info+ })+ .collect();++ (text, row_infos, excerpt_boundary_rows, regions)+ }++ fn diffs_updated(&mut self, cx: &mut App) {+ let buffer_ids = self.diffs.keys().copied().collect::<Vec<_>>();+ for buffer_id in buffer_ids {+ self.update_expanded_diff_hunks_for_buffer(buffer_id, cx);+ }+ }++ fn add_diff(&mut self, diff: Entity<BufferDiff>, cx: &mut App) {+ let buffer_id = diff.read(cx).buffer_id;+ self.diffs.insert(buffer_id, diff);+ }++ fn add_inverted_diff(+ &mut self,+ diff: Entity<BufferDiff>,+ main_buffer: Entity<language::Buffer>,+ cx: &App,+ ) {+ let base_text_buffer_id = diff.read(cx).base_text(cx).remote_id();+ self.inverted_diffs+ .insert(base_text_buffer_id, (diff, main_buffer));+ }++ fn update_expanded_diff_hunks_for_buffer(&mut self, buffer_id: BufferId, cx: &mut App) {+ let excerpts = self+ .excerpts+ .iter()+ .filter(|excerpt| excerpt.buffer.read(cx).remote_id() == buffer_id)+ .collect::<Vec<_>>();+ let Some(buffer) = excerpts.first().map(|excerpt| excerpt.buffer.clone()) else {+ self.expanded_diff_hunks_by_buffer.remove(&buffer_id);+ return;+ };+ let buffer_snapshot = buffer.read(cx).snapshot();+ let Some(diff) = self.diffs.get(&buffer_id) else {+ self.expanded_diff_hunks_by_buffer.remove(&buffer_id);+ return;+ };+ let diff = diff.read(cx).snapshot(cx);+ let hunks = diff+ .hunks_in_row_range(0..u32::MAX, &buffer_snapshot)+ .collect::<Vec<_>>();+ self.expanded_diff_hunks_by_buffer+ .entry(buffer_id)+ .or_default()+ .retain(|hunk_anchor| {+ if !hunk_anchor.is_valid(&buffer_snapshot) {+ return false;+ }++ let Ok(ix) = hunks.binary_search_by(|hunk| {+ hunk.buffer_range.start.cmp(hunk_anchor, &buffer_snapshot)+ }) else {+ return false;+ };+ let hunk_range = hunks[ix].buffer_range.to_point(&buffer_snapshot);+ excerpts.iter().any(|excerpt| {+ let excerpt_range = excerpt.range.to_point(&buffer_snapshot);+ hunk_range.start >= excerpt_range.start && hunk_range.start <= excerpt_range.end+ })+ });+ }++ fn anchor_to_offset(&self, anchor: &Anchor, cx: &App) -> Option<MultiBufferOffset> {+ if anchor.diff_base_anchor().is_some() {+ panic!("reference multibuffer cannot yet resolve anchors inside deleted hunks");+ }+ let (anchor, snapshot, path_key) = self.anchor_to_buffer_anchor(anchor, cx)?;+ // TODO(cole) can maybe make this and expected content call a common function instead+ let (text, _, _, regions) = self.expected_content(cx);++ // Locate the first region that contains or is past the putative location of the buffer anchor+ let ix = regions.partition_point(|region| {+ let excerpt = region+ .excerpt+ .as_ref()+ .expect("should have no buffers in empty reference multibuffer");+ excerpt+ .path_key+ .cmp(&path_key)+ .then_with(|| {+ if excerpt.range.end.cmp(&anchor, &snapshot).is_lt() {+ Ordering::Less+ } else if excerpt.range.start.cmp(&anchor, &snapshot).is_gt() {+ Ordering::Greater+ } else {+ Ordering::Equal+ }+ })+ .then_with(|| {+ if let Some(deleted_hunk_anchor) = region.deleted_hunk_anchor {+ deleted_hunk_anchor.cmp(&anchor, &snapshot)+ } else {+ let point = anchor.to_point(&snapshot);+ assert_eq!(region.buffer_id, Some(snapshot.remote_id()));+ if region.buffer_range.end < point {+ Ordering::Less+ } else if region.buffer_range.start > point {+ Ordering::Greater+ } else {+ Ordering::Equal+ }+ }+ })+ .is_lt()+ });++ let Some(region) = regions.get(ix) else {+ return Some(MultiBufferOffset(text.len()));+ };++ let offset = if region.buffer_id == Some(snapshot.remote_id()) {+ let buffer_offset = anchor.to_offset(&snapshot);+ let buffer_range = region.buffer_range.to_offset(&snapshot);+ assert!(buffer_offset <= buffer_range.end);+ let overshoot = buffer_offset.saturating_sub(buffer_range.start);+ region.range.start + overshoot+ } else {+ region.range.start+ };+ Some(MultiBufferOffset(offset))+ }++ fn anchor_to_buffer_anchor(+ &self,+ anchor: &Anchor,+ cx: &App,+ ) -> Option<(text::Anchor, BufferSnapshot, PathKey)> {+ let (excerpt, anchor) = match anchor {+ Anchor::Min => {+ let excerpt = self.excerpts.first()?;+ (excerpt, excerpt.range.start)+ }+ Anchor::Excerpt(excerpt_anchor) => (+ self.excerpts.iter().find(|excerpt| {+ excerpt.buffer.read(cx).remote_id() == excerpt_anchor.buffer_id()+ })?,+ excerpt_anchor.text_anchor,+ ),+ Anchor::Max => {+ let excerpt = self.excerpts.last()?;+ (excerpt, excerpt.range.end)+ }+ };++ Some((+ anchor,+ excerpt.buffer.read(cx).snapshot(),+ excerpt.path_key.clone(),+ ))+ }+}++fn mutate_excerpt_ranges(+ rng: &mut StdRng,+ existing_ranges: &mut Vec<Range<Point>>,+ buffer: &BufferSnapshot,+ operations: u32,+) {+ let mut ranges_to_add = Vec::new();++ for _ in 0..operations {+ match rng.random_range(0..5) {+ 0..=1 if !existing_ranges.is_empty() => {+ let index = rng.random_range(0..existing_ranges.len());+ log::info!("Removing excerpt at index {index}");+ existing_ranges.remove(index);+ }+ _ => {+ let end_row = rng.random_range(0..=buffer.max_point().row);+ let start_row = rng.random_range(0..=end_row);+ let end_col = buffer.line_len(end_row);+ log::info!(+ "Inserting excerpt for buffer {:?}, row range {:?}",+ buffer.remote_id(),+ start_row..end_row+ );+ ranges_to_add.push(Point::new(start_row, 0)..Point::new(end_row, end_col));+ }+ }+ }++ existing_ranges.extend(ranges_to_add);+ existing_ranges.sort_by_key(|r| r.start);+}++fn check_multibuffer(+ multibuffer: &MultiBuffer,+ reference: &ReferenceMultibuffer,+ anchors: &[Anchor],+ cx: &App,+ rng: &mut StdRng,+) {+ let snapshot = multibuffer.snapshot(cx);+ let actual_text = snapshot.text();+ let actual_boundary_rows = snapshot+ .excerpt_boundaries_in_range(MultiBufferOffset(0)..)+ .map(|b| b.row)+ .collect::<HashSet<_>>();+ let actual_row_infos = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();++ let anchors_to_check = anchors+ .iter()+ .filter_map(|anchor| {+ snapshot+ .anchor_to_buffer_anchor(*anchor)+ .map(|(anchor, _)| anchor)+ })+ // Intentionally mix in some anchors that are (in general) not contained in any excerpt+ .chain(+ reference+ .excerpts+ .iter()+ .map(|excerpt| excerpt.buffer.read(cx).remote_id())+ .dedup()+ .flat_map(|buffer_id| {+ [+ text::Anchor::min_for_buffer(buffer_id),+ text::Anchor::max_for_buffer(buffer_id),+ ]+ }),+ )+ .map(|anchor| snapshot.anchor_in_buffer(anchor).unwrap())+ .collect::<Vec<_>>();++ let (expected_text, expected_row_infos, expected_boundary_rows, _) =+ reference.expected_content(cx);+ let expected_anchor_offsets = anchors_to_check+ .iter()+ .map(|anchor| reference.anchor_to_offset(anchor, cx).unwrap())+ .collect::<Vec<_>>();++ let has_diff = actual_row_infos+ .iter()+ .any(|info| info.diff_status.is_some())+ || expected_row_infos+ .iter()+ .any(|info| info.diff_status.is_some());+ let actual_diff = format_diff(+ &actual_text,+ &actual_row_infos,+ &actual_boundary_rows,+ Some(has_diff),+ );+ let expected_diff = format_diff(+ &expected_text,+ &expected_row_infos,+ &expected_boundary_rows,+ Some(has_diff),+ );++ log::info!("Multibuffer content:\n{}", actual_diff);++ assert_eq!(+ actual_row_infos.len(),+ actual_text.split('\n').count(),+ "line count: {}",+ actual_text.split('\n').count()+ );+ pretty_assertions::assert_eq!(actual_diff, expected_diff);+ pretty_assertions::assert_eq!(actual_text, expected_text);+ pretty_assertions::assert_eq!(actual_row_infos, expected_row_infos);++ for _ in 0..5 {+ let start_row = rng.random_range(0..=expected_row_infos.len());+ assert_eq!(+ snapshot+ .row_infos(MultiBufferRow(start_row as u32))+ .collect::<Vec<_>>(),+ &expected_row_infos[start_row..],+ "buffer_rows({})",+ start_row+ );+ }++ assert_eq!(+ snapshot.widest_line_number(),+ expected_row_infos+ .into_iter()+ .filter_map(|info| {+ // For inverted diffs, deleted rows are visible and should be counted.+ // Only filter out deleted rows that are NOT from inverted diffs.+ let is_inverted_diff = info+ .buffer_id+ .is_some_and(|id| reference.inverted_diffs.contains_key(&id));+ if info.diff_status.is_some_and(|status| status.is_deleted()) && !is_inverted_diff {+ None+ } else {+ info.buffer_row+ }+ })+ .max()+ .unwrap()+ + 1+ );+ for i in 0..snapshot.len().0 {+ let (_, excerpt_range) = snapshot+ .excerpt_containing(MultiBufferOffset(i)..MultiBufferOffset(i))+ .unwrap();+ reference+ .excerpts+ .iter()+ .find(|reference_excerpt| reference_excerpt.range == excerpt_range.context)+ .expect("corresponding excerpt should exist in reference multibuffer");+ }++ assert_consistent_line_numbers(&snapshot);+ assert_position_translation(&snapshot);++ for (row, line) in expected_text.split('\n').enumerate() {+ assert_eq!(+ snapshot.line_len(MultiBufferRow(row as u32)),+ line.len() as u32,+ "line_len({}).",+ row+ );+ }++ let text_rope = Rope::from(expected_text.as_str());+ for _ in 0..10 {+ let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);+ let start_ix = text_rope.clip_offset(rng.random_range(0..=end_ix), Bias::Left);++ let text_for_range = snapshot+ .text_for_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))+ .collect::<String>();+ assert_eq!(+ text_for_range,+ &expected_text[start_ix..end_ix],+ "incorrect text for range {:?}",+ start_ix..end_ix+ );++ let expected_summary =+ MBTextSummary::from(TextSummary::from(&expected_text[start_ix..end_ix]));+ assert_eq!(+ snapshot.text_summary_for_range::<MBTextSummary, _>(+ MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix)+ ),+ expected_summary,+ "incorrect summary for range {:?}",+ start_ix..end_ix+ );+ }++ // Anchor resolution+ let summaries = snapshot.summaries_for_anchors::<MultiBufferOffset, _>(anchors);+ assert_eq!(anchors.len(), summaries.len());+ for (anchor, resolved_offset) in anchors.iter().zip(summaries) {+ assert!(resolved_offset <= snapshot.len());+ assert_eq!(+ snapshot.summary_for_anchor::<MultiBufferOffset>(anchor),+ resolved_offset,+ "anchor: {:?}",+ anchor+ );+ }++ let actual_anchor_offsets = anchors_to_check+ .into_iter()+ .map(|anchor| anchor.to_offset(&snapshot))+ .collect::<Vec<_>>();+ assert_eq!(+ actual_anchor_offsets, expected_anchor_offsets,+ "buffer anchor resolves to wrong offset"+ );++ for _ in 0..10 {+ let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);+ assert_eq!(+ snapshot+ .reversed_chars_at(MultiBufferOffset(end_ix))+ .collect::<String>(),+ expected_text[..end_ix].chars().rev().collect::<String>(),+ );+ }++ for _ in 0..10 {+ let end_ix = rng.random_range(0..=text_rope.len());+ let end_ix = text_rope.floor_char_boundary(end_ix);+ let start_ix = rng.random_range(0..=end_ix);+ let start_ix = text_rope.floor_char_boundary(start_ix);+ assert_eq!(+ snapshot+ .bytes_in_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))+ .flatten()+ .copied()+ .collect::<Vec<_>>(),+ expected_text.as_bytes()[start_ix..end_ix].to_vec(),+ "bytes_in_range({:?})",+ start_ix..end_ix,+ );+ }+}++fn check_multibuffer_edits(+ snapshot: &MultiBufferSnapshot,+ old_snapshot: &MultiBufferSnapshot,+ subscription: Subscription<MultiBufferOffset>,+) {+ let edits = subscription.consume().into_inner();++ log::info!(+ "applying subscription edits to old text: {:?}: {:#?}",+ old_snapshot.text(),+ edits,+ );++ let mut text = old_snapshot.text();+ for edit in edits {+ let new_text: String = snapshot+ .text_for_range(edit.new.start..edit.new.end)+ .collect();+ text.replace_range(+ (edit.new.start.0..edit.new.start.0 + (edit.old.end.0 - edit.old.start.0)).clone(),+ &new_text,+ );+ pretty_assertions::assert_eq!(+ &text[0..edit.new.end.0],+ snapshot+ .text_for_range(MultiBufferOffset(0)..edit.new.end)+ .collect::<String>()+ );+ }+ pretty_assertions::assert_eq!(text, snapshot.text());+}++fn format_diff(+ text: &str,+ row_infos: &Vec<RowInfo>,+ boundary_rows: &HashSet<MultiBufferRow>,+ has_diff: Option<bool>,+) -> String {+ let has_diff =+ has_diff.unwrap_or_else(|| row_infos.iter().any(|info| info.diff_status.is_some()));+ text.split('\n')+ .enumerate()+ .zip(row_infos)+ .map(|((ix, line), info)| {+ let marker = match info.diff_status.map(|status| status.kind) {+ Some(DiffHunkStatusKind::Added) => "+ ",+ Some(DiffHunkStatusKind::Deleted) => "- ",+ Some(DiffHunkStatusKind::Modified) => unreachable!(),+ None => {+ if has_diff && !line.is_empty() {+ " "+ } else {+ ""+ }+ }+ };+ let boundary_row = if boundary_rows.contains(&MultiBufferRow(ix as u32)) {+ if has_diff {+ " ----------\n"+ } else {+ "---------\n"+ }+ } else {+ ""+ };+ let expand = info+ .expand_info+ .as_ref()+ .map(|expand_info| match expand_info.direction {+ ExpandExcerptDirection::Up => " [↑]",+ ExpandExcerptDirection::Down => " [↓]",+ ExpandExcerptDirection::UpAndDown => " [↕]",+ })+ .unwrap_or_default();++ format!("{boundary_row}{marker}{line}{expand}")+ // let mbr = info+ // .multibuffer_row+ // .map(|row| format!("{:0>3}", row.0))+ // .unwrap_or_else(|| "???".to_string());+ // let byte_range = format!("{byte_range_start:0>3}..{byte_range_end:0>3}");+ // format!("{boundary_row}Row: {mbr}, Bytes: {byte_range} | {marker}{line}{expand}")+ })+ .collect::<Vec<_>>()+ .join("\n")+}++// fn format_transforms(snapshot: &MultiBufferSnapshot) -> String {+// snapshot+// .diff_transforms+// .iter()+// .map(|transform| {+// let (kind, summary) = match transform {+// DiffTransform::DeletedHunk { summary, .. } => (" Deleted", (*summary).into()),+// DiffTransform::FilteredInsertedHunk { summary, .. } => (" Filtered", *summary),+// DiffTransform::InsertedHunk { summary, .. } => (" Inserted", *summary),+// DiffTransform::Unmodified { summary, .. } => ("Unmodified", *summary),+// };+// format!("{kind}(len: {}, lines: {:?})", summary.len, summary.lines)+// })+// .join("\n")+// }++// fn format_excerpts(snapshot: &MultiBufferSnapshot) -> String {+// snapshot+// .excerpts+// .iter()+// .map(|excerpt| {+// format!(+// "Excerpt(buffer_range = {:?}, lines = {:?}, has_trailing_newline = {:?})",+// excerpt.range.context.to_point(&excerpt.buffer),+// excerpt.text_summary.lines,+// excerpt.has_trailing_newline+// )+// })+// .join("\n")+// }++#[track_caller]+fn assert_excerpts_match(+ multibuffer: &Entity<MultiBuffer>,+ cx: &mut TestAppContext,+ expected: &str,+) {+ let mut output = String::new();+ multibuffer.read_with(cx, |multibuffer, cx| {+ let snapshot = multibuffer.snapshot(cx);+ for excerpt in multibuffer.snapshot(cx).excerpts() {+ output.push_str("-----\n");+ output.extend(+ snapshot+ .buffer_for_id(excerpt.context.start.buffer_id)+ .unwrap()+ .text_for_range(excerpt.context),+ );+ if !output.ends_with('\n') {+ output.push('\n');+ }+ }+ });+ assert_eq!(output, expected);+}++#[track_caller]+fn assert_new_snapshot(+ multibuffer: &Entity<MultiBuffer>,+ snapshot: &mut MultiBufferSnapshot,+ subscription: &mut Subscription<MultiBufferOffset>,+ cx: &mut TestAppContext,+ expected_diff: &str,+) {+ let new_snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));+ let actual_text = new_snapshot.text();+ let line_infos = new_snapshot+ .row_infos(MultiBufferRow(0))+ .collect::<Vec<_>>();+ let actual_diff = format_diff(&actual_text, &line_infos, &Default::default(), None);+ pretty_assertions::assert_eq!(actual_diff, expected_diff);+ check_edits(+ snapshot,+ &new_snapshot,+ &subscription.consume().into_inner(),+ );+ *snapshot = new_snapshot;+}++#[track_caller]+fn check_edits(+ old_snapshot: &MultiBufferSnapshot,+ new_snapshot: &MultiBufferSnapshot,+ edits: &[Edit<MultiBufferOffset>],+) {+ let mut text = old_snapshot.text();+ let new_text = new_snapshot.text();+ for edit in edits.iter().rev() {+ if !text.is_char_boundary(edit.old.start.0)+ || !text.is_char_boundary(edit.old.end.0)+ || !new_text.is_char_boundary(edit.new.start.0)+ || !new_text.is_char_boundary(edit.new.end.0)+ {+ panic!(+ "invalid edits: {:?}\nold text: {:?}\nnew text: {:?}",+ edits, text, new_text+ );+ }++ text.replace_range(+ edit.old.start.0..edit.old.end.0,+ &new_text[edit.new.start.0..edit.new.end.0],+ );+ }++ pretty_assertions::assert_eq!(text, new_text, "invalid edits: {:?}", edits);+}++#[track_caller]+fn assert_chunks_in_ranges(snapshot: &MultiBufferSnapshot) {+ let full_text = snapshot.text();+ for ix in 0..full_text.len() {+ let mut chunks = snapshot.chunks(+ MultiBufferOffset(0)..snapshot.len(),+ LanguageAwareStyling {+ tree_sitter: false,+ diagnostics: false,+ },+ );+ chunks.seek(MultiBufferOffset(ix)..snapshot.len());+ let tail = chunks.map(|chunk| chunk.text).collect::<String>();+ assert_eq!(tail, &full_text[ix..], "seek to range: {:?}", ix..);+ }+}++#[track_caller]+fn assert_consistent_line_numbers(snapshot: &MultiBufferSnapshot) {+ let all_line_numbers = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();+ for start_row in 1..all_line_numbers.len() {+ let line_numbers = snapshot+ .row_infos(MultiBufferRow(start_row as u32))+ .collect::<Vec<_>>();+ assert_eq!(+ line_numbers,+ all_line_numbers[start_row..],+ "start_row: {start_row}"+ );+ }+}++#[track_caller]+fn assert_position_translation(snapshot: &MultiBufferSnapshot) {+ let text = Rope::from(snapshot.text());++ let mut left_anchors = Vec::new();+ let mut right_anchors = Vec::new();+ let mut offsets = Vec::new();+ let mut points = Vec::new();+ for offset in 0..=text.len() + 1 {+ let offset = MultiBufferOffset(offset);+ let clipped_left = snapshot.clip_offset(offset, Bias::Left);+ let clipped_right = snapshot.clip_offset(offset, Bias::Right);+ assert_eq!(+ clipped_left.0,+ text.clip_offset(offset.0, Bias::Left),+ "clip_offset({offset:?}, Left)"+ );+ assert_eq!(+ clipped_right.0,+ text.clip_offset(offset.0, Bias::Right),+ "clip_offset({offset:?}, Right)"+ );+ assert_eq!(+ snapshot.offset_to_point(clipped_left),+ text.offset_to_point(clipped_left.0),+ "offset_to_point({})",+ clipped_left.0+ );+ assert_eq!(+ snapshot.offset_to_point(clipped_right),+ text.offset_to_point(clipped_right.0),+ "offset_to_point({})",+ clipped_right.0+ );+ let anchor_after = snapshot.anchor_after(clipped_left);+ assert_eq!(+ anchor_after.to_offset(snapshot),+ clipped_left,+ "anchor_after({}).to_offset {anchor_after:?}",+ clipped_left.0+ );+ let anchor_before = snapshot.anchor_before(clipped_left);+ assert_eq!(+ anchor_before.to_offset(snapshot),+ clipped_left,+ "anchor_before({}).to_offset",+ clipped_left.0+ );+ left_anchors.push(anchor_before);+ right_anchors.push(anchor_after);+ offsets.push(clipped_left);+ points.push(text.offset_to_point(clipped_left.0));+ }++ for row in 0..text.max_point().row {+ for column in 0..text.line_len(row) + 1 {+ let point = Point { row, column };+ let clipped_left = snapshot.clip_point(point, Bias::Left);+ let clipped_right = snapshot.clip_point(point, Bias::Right);+ assert_eq!(+ clipped_left,+ text.clip_point(point, Bias::Left),+ "clip_point({point:?}, Left)"+ );+ assert_eq!(+ clipped_right,+ text.clip_point(point, Bias::Right),+ "clip_point({point:?}, Right)"+ );+ assert_eq!(+ snapshot.point_to_offset(clipped_left).0,+ text.point_to_offset(clipped_left),+ "point_to_offset({clipped_left:?})"+ );+ assert_eq!(+ snapshot.point_to_offset(clipped_right).0,+ text.point_to_offset(clipped_right),+ "point_to_offset({clipped_right:?})"+ );+ }+ }++ assert_eq!(+ snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&left_anchors),+ offsets,+ "left_anchors <-> offsets"+ );+ assert_eq!(+ snapshot.summaries_for_anchors::<Point, _>(&left_anchors),+ points,+ "left_anchors <-> points"+ );+ assert_eq!(+ snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&right_anchors),+ offsets,+ "right_anchors <-> offsets"+ );+ assert_eq!(+ snapshot.summaries_for_anchors::<Point, _>(&right_anchors),+ points,+ "right_anchors <-> points"+ );++ for (anchors, bias) in [(&left_anchors, Bias::Left), (&right_anchors, Bias::Right)] {+ for (ix, (offset, anchor)) in offsets.iter().zip(anchors).enumerate() {+ if ix > 0 && *offset == MultiBufferOffset(252) && offset > &offsets[ix - 1] {+ let prev_anchor = left_anchors[ix - 1];assert!(- resolution_consistent,- "after step {step} ({op:?}), comparison contradicts resolution:\n\- anchor {i}: {:?}\n resolves to {offset_i:?}\n\- anchor {j}: {:?}\n resolves to {offset_j:?}\n\- but compares {ordering:?}",- anchors[i], anchors[j],+ anchor.cmp(&prev_anchor, snapshot).is_gt(),+ "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_gt()",+ offsets[ix],+ offsets[ix - 1],+ );+ assert!(+ prev_anchor.cmp(anchor, snapshot).is_lt(),+ "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_lt()",+ offsets[ix - 1],+ offsets[ix],);-- if let Some(previous) = previous_orderings.insert((i, j), ordering) {- let inverted = matches!(- (previous, ordering),- (cmp::Ordering::Less, cmp::Ordering::Greater)- | (cmp::Ordering::Greater, cmp::Ordering::Less)- );- assert!(- !inverted,- "after step {step} ({op:?}), comparison inverted over time:\n\- anchor {i}: {:?}\n\- anchor {j}: {:?}\n\- compared {previous:?} before this step, {ordering:?} after",- anchors[i], anchors[j],- );- }}}}-}-/// Distilled from `test_anchor_comparison_tracks_resolution`'s minimal-/// shrunk counterexample (create anchor, re-key the path, create anchor).-/// After a path key is reused for a different buffer, an anchor into the-/// departed buffer sorts against anchors into the new buffer by buffer id,-/// so resolution must land it on the matching side of the path's region:-/// the start when the departed buffer's id is lower than the current-/// occupant's, the end otherwise. When resolution instead ignored that-/// order (it always chose the end), sorted-input consumers feeding-/// comparison-sorted anchors to forward-only cursors walked backward in-/// offset space — the "cannot seek backward" crash family (e.g. ZED-95K).-#[gpui::test]-async fn test_stale_path_anchor_comparison_tracks_resolution(cx: &mut TestAppContext) {- let old_buffer = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));- multibuffer.update(cx, |multibuffer, cx| {- let max_point = old_buffer.read(cx).max_point();- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- old_buffer.clone(),- [Point::zero()..max_point],- 0,- cx,- );- });- let stale = multibuffer.read_with(cx, |multibuffer, cx| {- multibuffer- .snapshot(cx)- .anchor_at(MultiBufferOffset(0), Bias::Right)- });+ if let Some((buffer, offset)) = snapshot.point_to_buffer_offset(snapshot.max_point()) {+ assert!(offset.0 <= buffer.len());+ }+ if let Some((buffer, point)) = snapshot.point_to_buffer_point(snapshot.max_point()) {+ assert!(point <= buffer.max_point());+ }+}- let new_buffer = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));- multibuffer.update(cx, |multibuffer, cx| {- let max_point = new_buffer.read(cx).max_point();- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- new_buffer.clone(),- [Point::zero()..max_point],- 0,- cx,+fn assert_line_indents(snapshot: &MultiBufferSnapshot) {+ let max_row = snapshot.max_point().row;+ let buffer_id = snapshot.excerpts().next().unwrap().context.start.buffer_id;+ let text = text::Buffer::new(ReplicaId::LOCAL, buffer_id, snapshot.text());+ let mut line_indents = text+ .line_indents_in_row_range(0..max_row + 1)+ .collect::<Vec<_>>();+ for start_row in 0..snapshot.max_point().row {+ pretty_assertions::assert_eq!(+ snapshot+ .line_indents(MultiBufferRow(start_row), |_| true)+ .map(|(row, indent, _)| (row.0, indent))+ .collect::<Vec<_>>(),+ &line_indents[(start_row as usize)..],+ "line_indents({start_row})");- });- cx.run_until_parked();-- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- let fresh = snapshot.anchor_at(MultiBufferOffset(0), Bias::Right);+ }- let ordering = stale.cmp(&fresh, &snapshot);- let stale_offset = stale.to_offset(&snapshot);- let fresh_offset = fresh.to_offset(&snapshot);- let resolution_consistent = match ordering {- cmp::Ordering::Less => stale_offset <= fresh_offset,- cmp::Ordering::Equal => stale_offset == fresh_offset,- cmp::Ordering::Greater => stale_offset >= fresh_offset,- };- assert!(- resolution_consistent,- "stale anchor {stale:?} resolves to {stale_offset:?} and fresh anchor {fresh:?} \- resolves to {fresh_offset:?}, but they compare {ordering:?}"+ line_indents.reverse();+ pretty_assertions::assert_eq!(+ snapshot+ .reversed_line_indents(MultiBufferRow(max_row), |_| true)+ .map(|(row, indent, _)| (row.0, indent))+ .collect::<Vec<_>>(),+ &line_indents[..],+ "reversed_line_indents({max_row})");}-/// Distilled from `test_anchor_comparison_tracks_resolution`'s second-/// shrunk counterexample. An expanded deleted hunk's phantom rows occupy-/// its attachment anchor's tie space in the buffer's CRDT order: anchor-/// comparison places a plain buffer anchor after the hunk's rows exactly-/// when it sorts past the attachment anchor, which can only happen once-/// the buffer text separating them has been deleted. Resolution must-/// place the anchor on the same side. It used to depend on which-/// transform the walk's cursor rested on: arriving on the deleted hunk-/// itself applied the CRDT rule, but arriving on the preceding buffer-/// content returned early, parking the anchor before rows it compares-/// after — so `to_offset` and a shared-cursor `summaries_for_anchors`-/// disagreed about the same anchor, and comparison-sorted consumers fed-/// forward-only cursors positions that moved backward.-#[gpui::test]-async fn test_collapsed_plain_anchor_resolves_past_deleted_hunk_rows(cx: &mut TestAppContext) {- let base_text = "DEL1\nDEL2\nbbb\nccc\nddd\n";- let buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));- let diff_a = cx.new(|cx| {- BufferDiff::new_with_base_text(base_text, &buffer_a.read(cx).text_snapshot(), cx)- });+fn collect_word_diffs(+ base_text: &str,+ modified_text: &str,+ cx: &mut TestAppContext,+) -> Vec<String> {+ let buffer = cx.new(|cx| Buffer::local(modified_text, cx));+ let diff = cx+ .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));+ cx.run_until_parked();+let multibuffer = cx.new(|cx| {- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);- multibuffer.set_all_diff_hunks_expanded(cx);+ let mut multibuffer = MultiBuffer::singleton(buffer.clone(), cx);+ multibuffer.add_diff(diff.clone(), cx);multibuffer});+multibuffer.update(cx, |multibuffer, cx| {- let max_point_a = buffer_a.read(cx).max_point();- multibuffer.set_excerpts_for_path(- PathKey::sorted(0),- buffer_a.clone(),- [Point::zero()..max_point_a],- 0,- cx,- );- multibuffer.add_diff(diff_a.clone(), cx);+ multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);});- cx.run_until_parked();- // Delete the first "d" (insertion offset 8), then anchor before the last- // "d" (insertion offset 10).- buffer_a.update(cx, |buffer, cx| {- buffer.edit([(8..9, "")], None, cx);- });- cx.run_until_parked();let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\ndd\n");- let plain_anchor = snapshot.anchor_at(MultiBufferOffset(19), Bias::Left);+ let text = snapshot.text();- // Recompute the diff against the edited buffer: a "-ddd/+dd" hunk- // appears, attached at the buffer position both anchors will collapse- // to. Anchor one character into its phantom "ddd" row.- let buffer_a_text_snapshot = buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());- diff_a- .update(cx, |diff, cx| {- diff.set_base_text(Some(base_text.into()), buffer_a_text_snapshot, cx)- })- .await;+ snapshot+ .diff_hunks()+ .flat_map(|hunk| hunk.word_diffs)+ .map(|range| text[range.start.0..range.end.0].to_string())+ .collect()+}++fn create_multibuffer_with_diff(+ base_text: &str,+ modified_text: &str,+ cx: &mut TestAppContext,+) -> Entity<MultiBuffer> {+ let buffer = cx.new(|cx| Buffer::local(modified_text, cx));+ let diff = cx+ .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));cx.run_until_parked();- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\nddd\ndd\n");- let hunk_anchor = snapshot.anchor_at(MultiBufferOffset(19), Bias::Right);- assert_eq!(- plain_anchor.cmp(&hunk_anchor, &snapshot),- cmp::Ordering::Greater- );- assert_eq!(plain_anchor.to_offset(&snapshot), MultiBufferOffset(23));- assert_eq!(hunk_anchor.to_offset(&snapshot), MultiBufferOffset(19));+ cx.new(|cx| {+ let mut mb = MultiBuffer::singleton(buffer, cx);+ mb.add_diff(diff, cx);+ mb+ })+}- // Delete the "d" separating the two anchors (insertion offset 9). Their- // text anchors now both collapse to the seam where the phantom row- // hangs, and only the CRDT order remembers which side of it each- // belongs on.- buffer_a.update(cx, |buffer, cx| {- buffer.edit([(8..9, "")], None, cx);- });- cx.run_until_parked();- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));- assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\nddd\nd\n");+fn assert_word_diff_ranges_valid(snapshot: &MultiBufferSnapshot) -> Vec<String> {+ let text = snapshot.text();+ let ranges: Vec<_> = snapshot+ .diff_hunks()+ .flat_map(|hunk| hunk.word_diffs)+ .collect();- assert_eq!(- plain_anchor.cmp(&hunk_anchor, &snapshot),- cmp::Ordering::Greater,- "comparison must not change: the buffer order of the anchors is immutable"- );- assert_eq!(- hunk_anchor.to_offset(&snapshot),- MultiBufferOffset(19),- "the hunk-interior anchor stays one character into the phantom row"- );- assert_eq!(- plain_anchor.to_offset(&snapshot),- MultiBufferOffset(22),- "the plain anchor sorts past the hunk's attachment anchor, so it must \- resolve past the phantom rows"- );- assert_eq!(- snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&[hunk_anchor, plain_anchor]),- vec![MultiBufferOffset(19), MultiBufferOffset(22)],- "the shared-cursor batch path must agree with individual resolution"- );+ for range in &ranges {+ assert!(+ range.start.0 <= range.end.0 && range.end.0 <= text.len(),+ "word diff range {:?} is outside text of length {}",+ range,+ text.len()+ );+ assert!(+ text.is_char_boundary(range.start.0),+ "invalid start boundary in {:?} (byte {})",+ range,+ range.start.0+ );+ assert!(+ text.is_char_boundary(range.end.0),+ "invalid end boundary in {:?} (byte {})",+ range,+ range.end.0+ );+ }++ ranges+ .iter()+ .map(|range| text[range.start.0..range.end.0].to_owned())+ .collect()}/// Operations for `test_anchor_comparison_tracks_resolution`, generated up