editor: Newtype WrapRow (#41843)

Makes a better distinction between `WrapRow` and `BlockRow` Release Notes: - N/A *or* Added/Fixed/Improved ...
2025-11-04 08:48:38 +00:00
parent 4002b32ad4
commit 3e7b8efb98
6 changed files with 484 additions and 332 deletions
@@ -0,0 +1,96 @@
+#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
+pub struct RowDelta(pub u32);
+
+impl RowDelta {
+    pub fn saturating_sub(self, other: RowDelta) -> RowDelta {
+        RowDelta(self.0.saturating_sub(other.0))
+    }
+}
+
+impl ::std::ops::Add for RowDelta {
+    type Output = RowDelta;
+
+    fn add(self, rhs: RowDelta) -> Self::Output {
+        RowDelta(self.0 + rhs.0)
+    }
+}
+
+impl ::std::ops::Sub for RowDelta {
+    type Output = RowDelta;
+
+    fn sub(self, rhs: RowDelta) -> Self::Output {
+        RowDelta(self.0 - rhs.0)
+    }
+}
+
+impl ::std::ops::AddAssign for RowDelta {
+    fn add_assign(&mut self, rhs: RowDelta) {
+        self.0 += rhs.0;
+    }
+}
+
+impl ::std::ops::SubAssign for RowDelta {
+    fn sub_assign(&mut self, rhs: RowDelta) {
+        self.0 -= rhs.0;
+    }
+}
+
+macro_rules! impl_for_row_types {
+    ($row:ident => $row_delta:ident) => {
+        impl $row {
+            pub fn saturating_sub(self, other: $row_delta) -> $row {
+                $row(self.0.saturating_sub(other.0))
+            }
+        }
+
+        impl ::std::ops::Add for $row {
+            type Output = Self;
+
+            fn add(self, rhs: Self) -> Self::Output {
+                Self(self.0 + rhs.0)
+            }
+        }
+
+        impl ::std::ops::Add<$row_delta> for $row {
+            type Output = Self;
+
+            fn add(self, rhs: $row_delta) -> Self::Output {
+                Self(self.0 + rhs.0)
+            }
+        }
+
+        impl ::std::ops::Sub for $row {
+            type Output = $row_delta;
+
+            fn sub(self, rhs: Self) -> Self::Output {
+                $row_delta(self.0 - rhs.0)
+            }
+        }
+
+        impl ::std::ops::Sub<$row_delta> for $row {
+            type Output = $row;
+
+            fn sub(self, rhs: $row_delta) -> Self::Output {
+                $row(self.0 - rhs.0)
+            }
+        }
+
+        impl ::std::ops::AddAssign for $row {
+            fn add_assign(&mut self, rhs: Self) {
+                self.0 += rhs.0;
+            }
+        }
+
+        impl ::std::ops::AddAssign<$row_delta> for $row {
+            fn add_assign(&mut self, rhs: $row_delta) {
+                self.0 += rhs.0;
+            }
+        }
+
+        impl ::std::ops::SubAssign<$row_delta> for $row {
+            fn sub_assign(&mut self, rhs: $row_delta) {
+                self.0 -= rhs.0;
+            }
+        }
+    };
+}
@@ -1,5 +1,6 @@
 use super::{
    Highlights,
+    dimensions::RowDelta,
    fold_map::{Chunk, FoldRows},
    tab_map::{self, TabEdit, TabPoint, TabSnapshot},
 };
@@ -7,13 +8,20 @@ use gpui::{App, AppContext as _, Context, Entity, Font, LineWrapper, Pixels, Tas
 use language::Point;
 use multi_buffer::{MultiBufferSnapshot, RowInfo};
 use smol::future::yield_now;
-use std::sync::LazyLock;
-use std::{cmp, collections::VecDeque, mem, ops::Range, time::Duration};
+use std::{cmp, collections::VecDeque, mem, ops::Range, sync::LazyLock, time::Duration};
 use sum_tree::{Bias, Cursor, Dimensions, SumTree};
 use text::Patch;

 pub use super::tab_map::TextSummary;
-pub type WrapEdit = text::Edit<u32>;
+pub type WrapEdit = text::Edit<WrapRow>;
+pub type WrapPatch = text::Patch<WrapRow>;
+
+#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
+pub struct WrapRow(pub u32);
+
+impl_for_row_types! {
+    WrapRow => RowDelta
+}

 /// Handles soft wrapping of text.
 ///
@@ -21,8 +29,8 @@ pub type WrapEdit = text::Edit<u32>;
 pub struct WrapMap {
    snapshot: WrapSnapshot,
    pending_edits: VecDeque<(TabSnapshot, Vec<TabEdit>)>,
-    interpolated_edits: Patch<u32>,
-    edits_since_sync: Patch<u32>,
+    interpolated_edits: WrapPatch,
+    edits_since_sync: WrapPatch,
    wrap_width: Option<Pixels>,
    background_task: Option<Task<()>>,
    font_with_size: (Font, Pixels),
@@ -54,7 +62,7 @@ pub struct WrapChunks<'a> {
    input_chunks: tab_map::TabChunks<'a>,
    input_chunk: Chunk<'a>,
    output_position: WrapPoint,
-    max_output_row: u32,
+    max_output_row: WrapRow,
    transforms: Cursor<'a, 'static, Transform, Dimensions<WrapPoint, TabPoint>>,
    snapshot: &'a WrapSnapshot,
 }
@@ -63,19 +71,19 @@ pub struct WrapChunks<'a> {
 pub struct WrapRows<'a> {
    input_buffer_rows: FoldRows<'a>,
    input_buffer_row: RowInfo,
-    output_row: u32,
+    output_row: WrapRow,
    soft_wrapped: bool,
-    max_output_row: u32,
+    max_output_row: WrapRow,
    transforms: Cursor<'a, 'static, Transform, Dimensions<WrapPoint, TabPoint>>,
 }

 impl WrapRows<'_> {
-    pub(crate) fn seek(&mut self, start_row: u32) {
+    pub(crate) fn seek(&mut self, start_row: WrapRow) {
        self.transforms
            .seek(&WrapPoint::new(start_row, 0), Bias::Left);
        let mut input_row = self.transforms.start().1.row();
        if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
-            input_row += start_row - self.transforms.start().0.row();
+            input_row += (start_row - self.transforms.start().0.row()).0;
        }
        self.soft_wrapped = self.transforms.item().is_some_and(|t| !t.is_isomorphic());
        self.input_buffer_rows.seek(input_row);
@@ -120,7 +128,7 @@ impl WrapMap {
        tab_snapshot: TabSnapshot,
        edits: Vec<TabEdit>,
        cx: &mut Context<Self>,
-    ) -> (WrapSnapshot, Patch<u32>) {
+    ) -> (WrapSnapshot, WrapPatch) {
        if self.wrap_width.is_some() {
            self.pending_edits.push_back((tab_snapshot, edits));
            self.flush_edits(cx);
@@ -226,8 +234,8 @@ impl WrapMap {
            let new_rows = self.snapshot.transforms.summary().output.lines.row + 1;
            self.snapshot.interpolated = false;
            self.edits_since_sync = self.edits_since_sync.compose(Patch::new(vec![WrapEdit {
-                old: 0..old_rows,
-                new: 0..new_rows,
+                old: WrapRow(0)..WrapRow(old_rows),
+                new: WrapRow(0)..WrapRow(new_rows),
            }]));
        }
    }
@@ -331,7 +339,7 @@ impl WrapSnapshot {
        self.tab_snapshot.buffer_snapshot()
    }

-    fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, tab_edits: &[TabEdit]) -> Patch<u32> {
+    fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, tab_edits: &[TabEdit]) -> WrapPatch {
        let mut new_transforms;
        if tab_edits.is_empty() {
            new_transforms = self.transforms.clone();
@@ -401,7 +409,7 @@ impl WrapSnapshot {
        tab_edits: &[TabEdit],
        wrap_width: Pixels,
        line_wrapper: &mut LineWrapper,
-    ) -> Patch<u32> {
+    ) -> WrapPatch {
        #[derive(Debug)]
        struct RowEdit {
            old_rows: Range<u32>,
@@ -554,7 +562,7 @@ impl WrapSnapshot {
        old_snapshot.compute_edits(tab_edits, self)
    }

-    fn compute_edits(&self, tab_edits: &[TabEdit], new_snapshot: &WrapSnapshot) -> Patch<u32> {
+    fn compute_edits(&self, tab_edits: &[TabEdit], new_snapshot: &WrapSnapshot) -> WrapPatch {
        let mut wrap_edits = Vec::with_capacity(tab_edits.len());
        let mut old_cursor = self.transforms.cursor::<TransformSummary>(());
        let mut new_cursor = new_snapshot.transforms.cursor::<TransformSummary>(());
@@ -581,8 +589,8 @@ impl WrapSnapshot {
            new_end += tab_edit.new.end.0 - new_cursor.start().input.lines;

            wrap_edits.push(WrapEdit {
-                old: old_start.row..old_end.row,
-                new: new_start.row..new_end.row,
+                old: WrapRow(old_start.row)..WrapRow(old_end.row),
+                new: WrapRow(new_start.row)..WrapRow(new_end.row),
            });
        }

@@ -592,7 +600,7 @@ impl WrapSnapshot {

    pub(crate) fn chunks<'a>(
        &'a self,
-        rows: Range<u32>,
+        rows: Range<WrapRow>,
        language_aware: bool,
        highlights: Highlights<'a>,
    ) -> WrapChunks<'a> {
@@ -627,17 +635,17 @@ impl WrapSnapshot {
        WrapPoint(self.transforms.summary().output.lines)
    }

-    pub fn line_len(&self, row: u32) -> u32 {
+    pub fn line_len(&self, row: WrapRow) -> u32 {
        let (start, _, item) = self.transforms.find::<Dimensions<WrapPoint, TabPoint>, _>(
            (),
-            &WrapPoint::new(row + 1, 0),
+            &WrapPoint::new(row + WrapRow(1), 0),
            Bias::Left,
        );
        if item.is_some_and(|transform| transform.is_isomorphic()) {
            let overshoot = row - start.0.row();
-            let tab_row = start.1.row() + overshoot;
+            let tab_row = start.1.row() + overshoot.0;
            let tab_line_len = self.tab_snapshot.line_len(tab_row);
-            if overshoot == 0 {
+            if overshoot.0 == 0 {
                start.0.column() + (tab_line_len - start.1.column())
            } else {
                tab_line_len
@@ -647,7 +655,7 @@ impl WrapSnapshot {
        }
    }

-    pub fn text_summary_for_range(&self, rows: Range<u32>) -> TextSummary {
+    pub fn text_summary_for_range(&self, rows: Range<WrapRow>) -> TextSummary {
        let mut summary = TextSummary::default();

        let start = WrapPoint::new(rows.start, 0);
@@ -708,10 +716,12 @@ impl WrapSnapshot {
        summary
    }

-    pub fn soft_wrap_indent(&self, row: u32) -> Option<u32> {
-        let (.., item) =
-            self.transforms
-                .find::<WrapPoint, _>((), &WrapPoint::new(row + 1, 0), Bias::Right);
+    pub fn soft_wrap_indent(&self, row: WrapRow) -> Option<u32> {
+        let (.., item) = self.transforms.find::<WrapPoint, _>(
+            (),
+            &WrapPoint::new(row + WrapRow(1), 0),
+            Bias::Right,
+        );
        item.and_then(|transform| {
            if transform.is_isomorphic() {
                None
@@ -725,14 +735,14 @@ impl WrapSnapshot {
        self.transforms.summary().output.longest_row
    }

-    pub fn row_infos(&self, start_row: u32) -> WrapRows<'_> {
+    pub fn row_infos(&self, start_row: WrapRow) -> WrapRows<'_> {
        let mut transforms = self
            .transforms
            .cursor::<Dimensions<WrapPoint, TabPoint>>(());
        transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left);
        let mut input_row = transforms.start().1.row();
        if transforms.item().is_some_and(|t| t.is_isomorphic()) {
-            input_row += start_row - transforms.start().0.row();
+            input_row += (start_row - transforms.start().0.row()).0;
        }
        let soft_wrapped = transforms.item().is_some_and(|t| !t.is_isomorphic());
        let mut input_buffer_rows = self.tab_snapshot.rows(input_row);
@@ -787,9 +797,9 @@ impl WrapSnapshot {
        self.tab_point_to_wrap_point(self.tab_snapshot.clip_point(self.to_tab_point(point), bias))
    }

-    pub fn prev_row_boundary(&self, mut point: WrapPoint) -> u32 {
+    pub fn prev_row_boundary(&self, mut point: WrapPoint) -> WrapRow {
        if self.transforms.is_empty() {
-            return 0;
+            return WrapRow(0);
        }

        *point.column_mut() = 0;
@@ -813,7 +823,7 @@ impl WrapSnapshot {
        unreachable!()
    }

-    pub fn next_row_boundary(&self, mut point: WrapPoint) -> Option<u32> {
+    pub fn next_row_boundary(&self, mut point: WrapPoint) -> Option<WrapRow> {
        point.0 += Point::new(1, 0);

        let mut cursor = self
@@ -833,13 +843,13 @@ impl WrapSnapshot {

    #[cfg(test)]
    pub fn text(&self) -> String {
-        self.text_chunks(0).collect()
+        self.text_chunks(WrapRow(0)).collect()
    }

    #[cfg(test)]
-    pub fn text_chunks(&self, wrap_row: u32) -> impl Iterator<Item = &str> {
+    pub fn text_chunks(&self, wrap_row: WrapRow) -> impl Iterator<Item = &str> {
        self.chunks(
-            wrap_row..self.max_point().row() + 1,
+            wrap_row..self.max_point().row() + WrapRow(1),
            false,
            Highlights::default(),
        )
@@ -867,21 +877,22 @@ impl WrapSnapshot {
            let mut input_buffer_rows = self.tab_snapshot.rows(0);
            let mut expected_buffer_rows = Vec::new();
            let mut prev_tab_row = 0;
-            for display_row in 0..=self.max_point().row() {
+            for display_row in 0..=self.max_point().row().0 {
+                let display_row = WrapRow(display_row);
                let tab_point = self.to_tab_point(WrapPoint::new(display_row, 0));
-                if tab_point.row() == prev_tab_row && display_row != 0 {
+                if tab_point.row() == prev_tab_row && display_row != WrapRow(0) {
                    expected_buffer_rows.push(None);
                } else {
                    expected_buffer_rows.push(input_buffer_rows.next().unwrap().buffer_row);
                }

                prev_tab_row = tab_point.row();
-                assert_eq!(self.line_len(display_row), text.line_len(display_row));
+                assert_eq!(self.line_len(display_row), text.line_len(display_row.0));
            }

            for start_display_row in 0..expected_buffer_rows.len() {
                assert_eq!(
-                    self.row_infos(start_display_row as u32)
+                    self.row_infos(WrapRow(start_display_row as u32))
                        .map(|row_info| row_info.buffer_row)
                        .collect::<Vec<_>>(),
                    &expected_buffer_rows[start_display_row..],
@@ -894,7 +905,7 @@ impl WrapSnapshot {
 }

 impl WrapChunks<'_> {
-    pub(crate) fn seek(&mut self, rows: Range<u32>) {
+    pub(crate) fn seek(&mut self, rows: Range<WrapRow>) {
        let output_start = WrapPoint::new(rows.start, 0);
        let output_end = WrapPoint::new(rows.end, 0);
        self.transforms.seek(&output_start, Bias::Right);
@@ -931,7 +942,7 @@ impl<'a> Iterator for WrapChunks<'a> {
                // Exclude newline starting prior to the desired row.
                start_ix = 1;
                summary.row = 0;
-            } else if self.output_position.row() + 1 >= self.max_output_row {
+            } else if self.output_position.row() + WrapRow(1) >= self.max_output_row {
                // Exclude soft indentation ending after the desired row.
                end_ix = 1;
                summary.column = 0;
@@ -997,7 +1008,7 @@ impl Iterator for WrapRows<'_> {
        let soft_wrapped = self.soft_wrapped;
        let diff_status = self.input_buffer_row.diff_status;

-        self.output_row += 1;
+        self.output_row += WrapRow(1);
        self.transforms
            .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left);
        if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
@@ -1107,12 +1118,12 @@ impl SumTreeExt for SumTree<Transform> {
 }

 impl WrapPoint {
-    pub fn new(row: u32, column: u32) -> Self {
-        Self(Point::new(row, column))
+    pub fn new(row: WrapRow, column: u32) -> Self {
+        Self(Point::new(row.0, column))
    }

-    pub fn row(self) -> u32 {
-        self.0.row
+    pub fn row(self) -> WrapRow {
+        WrapRow(self.0.row)
    }

    pub fn row_mut(&mut self) -> &mut u32 {
@@ -1417,14 +1428,14 @@ mod tests {
        for (snapshot, patch) in edits {
            let snapshot_text = Rope::from(snapshot.text().as_str());
            for edit in &patch {
-                let old_start = initial_text.point_to_offset(Point::new(edit.new.start, 0));
+                let old_start = initial_text.point_to_offset(Point::new(edit.new.start.0, 0));
                let old_end = initial_text.point_to_offset(cmp::min(
-                    Point::new(edit.new.start + edit.old.len() as u32, 0),
+                    Point::new(edit.new.start.0 + (edit.old.end - edit.old.start).0, 0),
                    initial_text.max_point(),
                ));
-                let new_start = snapshot_text.point_to_offset(Point::new(edit.new.start, 0));
+                let new_start = snapshot_text.point_to_offset(Point::new(edit.new.start.0, 0));
                let new_end = snapshot_text.point_to_offset(cmp::min(
-                    Point::new(edit.new.end, 0),
+                    Point::new(edit.new.end.0, 0),
                    snapshot_text.max_point(),
                ));
                let new_text = snapshot_text
@@ -1484,11 +1495,11 @@ mod tests {
    impl WrapSnapshot {
        fn verify_chunks(&mut self, rng: &mut impl Rng) {
            for _ in 0..5 {
-                let mut end_row = rng.random_range(0..=self.max_point().row());
+                let mut end_row = rng.random_range(0..=self.max_point().row().0);
                let start_row = rng.random_range(0..=end_row);
                end_row += 1;

-                let mut expected_text = self.text_chunks(start_row).collect::<String>();
+                let mut expected_text = self.text_chunks(WrapRow(start_row)).collect::<String>();
                if expected_text.ends_with('\n') {
                    expected_text.push('\n');
                }
@@ -1497,12 +1508,16 @@ mod tests {
                    .take((end_row - start_row) as usize)
                    .collect::<Vec<_>>()
                    .join("\n");
-                if end_row <= self.max_point().row() {
+                if end_row <= self.max_point().row().0 {
                    expected_text.push('\n');
                }

                let actual_text = self
-                    .chunks(start_row..end_row, true, Highlights::default())
+                    .chunks(
+                        WrapRow(start_row)..WrapRow(end_row),
+                        true,
+                        Highlights::default(),
+                    )
                    .map(|c| c.text)
                    .collect::<String>();
                assert_eq!(