From 742241a903f404b8f8fbb5723cb97da802945a04 Mon Sep 17 00:00:00 2001 From: Antonio Scandurra Date: Thu, 10 Jun 2021 14:06:27 +0200 Subject: [PATCH] Rename `Cursor::{start,end}` to `Cursor::{sum_start,sum_end}` --- zed/src/editor/buffer.rs | 28 ++++++++-------- zed/src/editor/buffer/rope.rs | 4 +-- zed/src/editor/display_map/fold_map.rs | 29 +++++++++-------- zed/src/sum_tree.rs | 44 +++++++++++++------------- zed/src/sum_tree/cursor.rs | 8 ++--- 5 files changed, 58 insertions(+), 55 deletions(-) diff --git a/zed/src/editor/buffer.rs b/zed/src/editor/buffer.rs index 566446a4e6d068767dab2f7b82e03bef2f632aca..3a2f62ace0bdd337159c3a20dcaa264768194c50 100644 --- a/zed/src/editor/buffer.rs +++ b/zed/src/editor/buffer.rs @@ -1210,7 +1210,7 @@ impl Buffer { old_fragments.slice(&VersionedOffset::Offset(ranges[0].start), Bias::Left, &cx); new_ropes.push_tree(new_fragments.summary().text); - let mut fragment_start = old_fragments.start().offset(); + let mut fragment_start = old_fragments.sum_start().offset(); for range in ranges { let fragment_end = old_fragments.end(&cx).offset(); @@ -1219,7 +1219,7 @@ impl Buffer { if fragment_end < range.start { // If the current fragment has been partially consumed, then consume the rest of it // and advance to the next fragment before slicing. - if fragment_start > old_fragments.start().offset() { + if fragment_start > old_fragments.sum_start().offset() { if fragment_end > fragment_start { let mut suffix = old_fragments.item().unwrap().clone(); suffix.len = fragment_end - fragment_start; @@ -1233,7 +1233,7 @@ impl Buffer { old_fragments.slice(&VersionedOffset::Offset(range.start), Bias::Left, &cx); new_ropes.push_tree(slice.summary().text); new_fragments.push_tree(slice, &None); - fragment_start = old_fragments.start().offset(); + fragment_start = old_fragments.sum_start().offset(); } // If we are at the end of a non-concurrent fragment, advance to the next one. @@ -1244,7 +1244,7 @@ impl Buffer { new_ropes.push_fragment(&fragment, fragment.visible); new_fragments.push(fragment, &None); old_fragments.next(&cx); - fragment_start = old_fragments.start().offset(); + fragment_start = old_fragments.sum_start().offset(); } // Skip over insertions that are concurrent to this edit, but have a lower lamport @@ -1312,7 +1312,7 @@ impl Buffer { // If the current fragment has been partially consumed, then consume the rest of it // and advance to the next fragment before slicing. - if fragment_start > old_fragments.start().offset() { + if fragment_start > old_fragments.sum_start().offset() { let fragment_end = old_fragments.end(&cx).offset(); if fragment_end > fragment_start { let mut suffix = old_fragments.item().unwrap().clone(); @@ -1539,7 +1539,7 @@ impl Buffer { let mut new_fragments = old_fragments.slice(&ranges[0].start, Bias::Right, &None); new_ropes.push_tree(new_fragments.summary().text); - let mut fragment_start = old_fragments.start().visible; + let mut fragment_start = old_fragments.sum_start().visible; for range in ranges { let fragment_end = old_fragments.end(&None).visible; @@ -1548,7 +1548,7 @@ impl Buffer { if fragment_end < range.start { // If the current fragment has been partially consumed, then consume the rest of it // and advance to the next fragment before slicing. - if fragment_start > old_fragments.start().visible { + if fragment_start > old_fragments.sum_start().visible { if fragment_end > fragment_start { let mut suffix = old_fragments.item().unwrap().clone(); suffix.len = fragment_end - fragment_start; @@ -1561,10 +1561,10 @@ impl Buffer { let slice = old_fragments.slice(&range.start, Bias::Right, &None); new_ropes.push_tree(slice.summary().text); new_fragments.push_tree(slice, &None); - fragment_start = old_fragments.start().visible; + fragment_start = old_fragments.sum_start().visible; } - let full_range_start = range.start + old_fragments.start().deleted; + let full_range_start = range.start + old_fragments.sum_start().deleted; // Preserve any portion of the current fragment that precedes this range. if fragment_start < range.start { @@ -1612,13 +1612,13 @@ impl Buffer { } } - let full_range_end = range.end + old_fragments.start().deleted; + let full_range_end = range.end + old_fragments.sum_start().deleted; edit.ranges.push(full_range_start..full_range_end); } // If the current fragment has been partially consumed, then consume the rest of it // and advance to the next fragment before slicing. - if fragment_start > old_fragments.start().visible { + if fragment_start > old_fragments.sum_start().visible { let fragment_end = old_fragments.end(&None).visible; if fragment_end > fragment_start { let mut suffix = old_fragments.item().unwrap().clone(); @@ -1663,7 +1663,7 @@ impl Buffer { let mut cursor = self.fragments.cursor::(); cursor.seek(&offset, bias, &None); Anchor::Middle { - offset: offset + cursor.start().deleted, + offset: offset + cursor.sum_start().deleted, bias, version: self.version(), } @@ -1692,7 +1692,7 @@ impl Buffer { 0 }; - self.text_summary_for_range(0..cursor.start() + overshoot) + self.text_summary_for_range(0..cursor.sum_start() + overshoot) } } } @@ -1718,7 +1718,7 @@ impl Buffer { &Some(version.clone()), ); let overshoot = offset - cursor.seek_start().offset(); - let summary = cursor.start(); + let summary = cursor.sum_start(); summary.visible + summary.deleted + overshoot } } diff --git a/zed/src/editor/buffer/rope.rs b/zed/src/editor/buffer/rope.rs index 565c4a173db5bb3225ef6f432feb8aeff2acfeb1..4c1a3ed56d709cb83a13fa032227771683b4547d 100644 --- a/zed/src/editor/buffer/rope.rs +++ b/zed/src/editor/buffer/rope.rs @@ -131,7 +131,7 @@ impl Rope { let mut cursor = self.chunks.cursor::(); cursor.seek(&offset, Bias::Left, &()); let overshoot = offset - cursor.seek_start(); - *cursor.start() + *cursor.sum_start() + cursor .item() .map_or(Point::zero(), |chunk| chunk.to_point(overshoot)) @@ -142,7 +142,7 @@ impl Rope { let mut cursor = self.chunks.cursor::(); cursor.seek(&point, Bias::Left, &()); let overshoot = point - cursor.seek_start(); - cursor.start() + cursor.item().map_or(0, |chunk| chunk.to_offset(overshoot)) + cursor.sum_start() + cursor.item().map_or(0, |chunk| chunk.to_offset(overshoot)) } pub fn clip_offset(&self, mut offset: usize, bias: Bias) -> usize { diff --git a/zed/src/editor/display_map/fold_map.rs b/zed/src/editor/display_map/fold_map.rs index efea294d0914a4de5ad8630b368bbc3224a7787a..3193d9002c24c9ae9aec1f15784e917b3d76a696 100644 --- a/zed/src/editor/display_map/fold_map.rs +++ b/zed/src/editor/display_map/fold_map.rs @@ -245,7 +245,7 @@ impl FoldMap { let mut cursor = transforms.cursor::(); cursor.seek(&display_point, Bias::Right, &()); let overshoot = display_point.0 - cursor.seek_start().0; - *cursor.start() + overshoot + *cursor.sum_start() + overshoot } pub fn to_display_point(&self, point: Point, cx: &AppContext) -> DisplayPoint { @@ -253,7 +253,10 @@ impl FoldMap { let mut cursor = transforms.cursor::(); cursor.seek(&point, Bias::Right, &()); let overshoot = point - cursor.seek_start(); - DisplayPoint(cmp::min(cursor.start().0 + overshoot, cursor.end(&()).0)) + DisplayPoint(cmp::min( + cursor.sum_start().0 + overshoot, + cursor.end(&()).0, + )) } fn sync(&self, cx: &AppContext) -> MutexGuard> { @@ -443,7 +446,7 @@ impl FoldMapSnapshot { let mut transform_cursor = self.transforms.cursor::(); transform_cursor.seek(&offset, Bias::Right, &()); let overshoot = offset.0 - transform_cursor.seek_start().0; - let buffer_offset = transform_cursor.start() + overshoot; + let buffer_offset = transform_cursor.sum_start() + overshoot; Chunks { transform_cursor, buffer_offset, @@ -456,11 +459,11 @@ impl FoldMapSnapshot { transform_cursor.seek(&range.end, Bias::Right, &()); let overshoot = range.end.0 - transform_cursor.seek_start().0; - let buffer_end = transform_cursor.start() + overshoot; + let buffer_end = transform_cursor.sum_start() + overshoot; transform_cursor.seek(&range.start, Bias::Right, &()); let overshoot = range.start.0 - transform_cursor.seek_start().0; - let buffer_start = transform_cursor.start() + overshoot; + let buffer_start = transform_cursor.sum_start() + overshoot; HighlightedChunks { transform_cursor, @@ -480,15 +483,15 @@ impl FoldMapSnapshot { pub fn to_display_offset(&self, point: DisplayPoint) -> DisplayOffset { let mut cursor = self.transforms.cursor::(); cursor.seek(&point, Bias::Right, &()); - let overshoot = point.0 - cursor.start().display.lines; - let mut offset = cursor.start().display.bytes; + let overshoot = point.0 - cursor.sum_start().display.lines; + let mut offset = cursor.sum_start().display.bytes; if !overshoot.is_zero() { let transform = cursor.item().expect("display point out of range"); assert!(transform.display_text.is_none()); let end_buffer_offset = self .buffer - .to_offset(cursor.start().buffer.lines + overshoot); - offset += end_buffer_offset - cursor.start().buffer.bytes; + .to_offset(cursor.sum_start().buffer.lines + overshoot); + offset += end_buffer_offset - cursor.sum_start().buffer.bytes; } DisplayOffset(offset) } @@ -497,7 +500,7 @@ impl FoldMapSnapshot { let mut cursor = self.transforms.cursor::(); cursor.seek(&point, Bias::Right, &()); let overshoot = point.0 - cursor.seek_start().0; - self.buffer.to_offset(*cursor.start() + overshoot) + self.buffer.to_offset(*cursor.sum_start() + overshoot) } #[cfg(test)] @@ -514,7 +517,7 @@ impl FoldMapSnapshot { } } else { let overshoot = offset.0 - transform_start; - let buffer_offset = cursor.start() + overshoot; + let buffer_offset = cursor.sum_start() + overshoot; let clipped_buffer_offset = self.buffer.clip_offset(buffer_offset, bias); DisplayOffset( (offset.0 as isize + (clipped_buffer_offset as isize - buffer_offset as isize)) @@ -539,7 +542,7 @@ impl FoldMapSnapshot { } } else { let overshoot = point.0 - transform_start; - let buffer_position = *cursor.start() + overshoot; + let buffer_position = *cursor.sum_start() + overshoot; let clipped_buffer_position = self.buffer.clip_point(buffer_position, bias); DisplayPoint::new( point.row(), @@ -695,7 +698,7 @@ impl<'a> Iterator for BufferRows<'a> { if self.cursor.item().is_some() { let overshoot = self.display_point - self.cursor.seek_start().0; - let buffer_point = *self.cursor.start() + overshoot; + let buffer_point = *self.cursor.sum_start() + overshoot; self.display_point.row += 1; Some(buffer_point.row) } else { diff --git a/zed/src/sum_tree.rs b/zed/src/sum_tree.rs index 1cadf1a4d47ea81fdc3500a8fb7dd195175f5639..c30c00d445291908729717de3c9d89cfcf8c6a84 100644 --- a/zed/src/sum_tree.rs +++ b/zed/src/sum_tree.rs @@ -651,7 +651,7 @@ mod tests { cursor.seek(&Count(pos), Bias::Right, &()); for i in 0..10 { - assert_eq!(cursor.start().0, pos); + assert_eq!(cursor.sum_start().0, pos); if pos > 0 { assert_eq!(cursor.prev_item().unwrap(), &reference_items[pos - 1]); @@ -710,7 +710,7 @@ mod tests { ); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), None); - assert_eq!(cursor.start(), &Sum(0)); + assert_eq!(cursor.sum_start(), &Sum(0)); // Single-element tree let mut tree = SumTree::::new(); @@ -722,23 +722,23 @@ mod tests { ); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); - assert_eq!(cursor.start(), &Sum(0)); + assert_eq!(cursor.sum_start(), &Sum(0)); cursor.next(&()); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&1)); - assert_eq!(cursor.start(), &Sum(1)); + assert_eq!(cursor.sum_start(), &Sum(1)); cursor.prev(&()); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); - assert_eq!(cursor.start(), &Sum(0)); + assert_eq!(cursor.sum_start(), &Sum(0)); let mut cursor = tree.cursor::(); assert_eq!(cursor.slice(&Count(1), Bias::Right, &()).items(&()), [1]); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&1)); - assert_eq!(cursor.start(), &Sum(1)); + assert_eq!(cursor.sum_start(), &Sum(1)); cursor.seek(&Count(0), Bias::Right, &()); assert_eq!( @@ -749,7 +749,7 @@ mod tests { ); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&1)); - assert_eq!(cursor.start(), &Sum(1)); + assert_eq!(cursor.sum_start(), &Sum(1)); // Multiple-element tree let mut tree = SumTree::new(); @@ -759,68 +759,68 @@ mod tests { assert_eq!(cursor.slice(&Count(2), Bias::Right, &()).items(&()), [1, 2]); assert_eq!(cursor.item(), Some(&3)); assert_eq!(cursor.prev_item(), Some(&2)); - assert_eq!(cursor.start(), &Sum(3)); + assert_eq!(cursor.sum_start(), &Sum(3)); cursor.next(&()); assert_eq!(cursor.item(), Some(&4)); assert_eq!(cursor.prev_item(), Some(&3)); - assert_eq!(cursor.start(), &Sum(6)); + assert_eq!(cursor.sum_start(), &Sum(6)); cursor.next(&()); assert_eq!(cursor.item(), Some(&5)); assert_eq!(cursor.prev_item(), Some(&4)); - assert_eq!(cursor.start(), &Sum(10)); + assert_eq!(cursor.sum_start(), &Sum(10)); cursor.next(&()); assert_eq!(cursor.item(), Some(&6)); assert_eq!(cursor.prev_item(), Some(&5)); - assert_eq!(cursor.start(), &Sum(15)); + assert_eq!(cursor.sum_start(), &Sum(15)); cursor.next(&()); cursor.next(&()); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&6)); - assert_eq!(cursor.start(), &Sum(21)); + assert_eq!(cursor.sum_start(), &Sum(21)); cursor.prev(&()); assert_eq!(cursor.item(), Some(&6)); assert_eq!(cursor.prev_item(), Some(&5)); - assert_eq!(cursor.start(), &Sum(15)); + assert_eq!(cursor.sum_start(), &Sum(15)); cursor.prev(&()); assert_eq!(cursor.item(), Some(&5)); assert_eq!(cursor.prev_item(), Some(&4)); - assert_eq!(cursor.start(), &Sum(10)); + assert_eq!(cursor.sum_start(), &Sum(10)); cursor.prev(&()); assert_eq!(cursor.item(), Some(&4)); assert_eq!(cursor.prev_item(), Some(&3)); - assert_eq!(cursor.start(), &Sum(6)); + assert_eq!(cursor.sum_start(), &Sum(6)); cursor.prev(&()); assert_eq!(cursor.item(), Some(&3)); assert_eq!(cursor.prev_item(), Some(&2)); - assert_eq!(cursor.start(), &Sum(3)); + assert_eq!(cursor.sum_start(), &Sum(3)); cursor.prev(&()); assert_eq!(cursor.item(), Some(&2)); assert_eq!(cursor.prev_item(), Some(&1)); - assert_eq!(cursor.start(), &Sum(1)); + assert_eq!(cursor.sum_start(), &Sum(1)); cursor.prev(&()); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); - assert_eq!(cursor.start(), &Sum(0)); + assert_eq!(cursor.sum_start(), &Sum(0)); cursor.prev(&()); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), None); - assert_eq!(cursor.start(), &Sum(0)); + assert_eq!(cursor.sum_start(), &Sum(0)); cursor.next(&()); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); - assert_eq!(cursor.start(), &Sum(0)); + assert_eq!(cursor.sum_start(), &Sum(0)); let mut cursor = tree.cursor::(); assert_eq!( @@ -831,7 +831,7 @@ mod tests { ); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&6)); - assert_eq!(cursor.start(), &Sum(21)); + assert_eq!(cursor.sum_start(), &Sum(21)); cursor.seek(&Count(3), Bias::Right, &()); assert_eq!( @@ -842,7 +842,7 @@ mod tests { ); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&6)); - assert_eq!(cursor.start(), &Sum(21)); + assert_eq!(cursor.sum_start(), &Sum(21)); // Seeking can bias left or right cursor.seek(&Count(1), Bias::Left, &()); diff --git a/zed/src/sum_tree/cursor.rs b/zed/src/sum_tree/cursor.rs index 7e2961baa21972a04c550b1f6a5514aaa7bebc80..c4cc68e7785236daf6e900224541e6a127177b74 100644 --- a/zed/src/sum_tree/cursor.rs +++ b/zed/src/sum_tree/cursor.rs @@ -59,17 +59,17 @@ where } } - pub fn start(&self) -> &U { + pub fn sum_start(&self) -> &U { &self.sum_dimension } pub fn end(&self, cx: &::Context) -> U { if let Some(item_summary) = self.item_summary() { - let mut end = self.start().clone(); + let mut end = self.sum_start().clone(); end.add_summary(item_summary, cx); end } else { - self.start().clone() + self.sum_start().clone() } } @@ -627,7 +627,7 @@ where } pub fn start(&self) -> &U { - self.cursor.start() + self.cursor.sum_start() } pub fn item(&self) -> Option<&'a T> {