1use super::{
   2    Highlights,
   3    dimensions::RowDelta,
   4    fold_map::{Chunk, FoldRows},
   5    tab_map::{self, TabEdit, TabPoint, TabSnapshot},
   6};
   7use gpui::{App, AppContext as _, Context, Entity, Font, LineWrapper, Pixels, Task};
   8use language::Point;
   9use multi_buffer::{MultiBufferSnapshot, RowInfo};
  10use smol::future::yield_now;
  11use std::{cmp, collections::VecDeque, mem, ops::Range, sync::LazyLock, time::Duration};
  12use sum_tree::{Bias, Cursor, Dimensions, SumTree};
  13use text::Patch;
  14
  15pub use super::tab_map::TextSummary;
  16pub type WrapEdit = text::Edit<WrapRow>;
  17pub type WrapPatch = text::Patch<WrapRow>;
  18
  19#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
  20pub struct WrapRow(pub u32);
  21
  22impl_for_row_types! {
  23    WrapRow => RowDelta
  24}
  25
  26/// Handles soft wrapping of text.
  27///
  28/// See the [`display_map` module documentation](crate::display_map) for more information.
  29pub struct WrapMap {
  30    snapshot: WrapSnapshot,
  31    pending_edits: VecDeque<(TabSnapshot, Vec<TabEdit>)>,
  32    interpolated_edits: WrapPatch,
  33    edits_since_sync: WrapPatch,
  34    wrap_width: Option<Pixels>,
  35    background_task: Option<Task<()>>,
  36    font_with_size: (Font, Pixels),
  37}
  38
  39#[derive(Clone)]
  40pub struct WrapSnapshot {
  41    pub(super) tab_snapshot: TabSnapshot,
  42    transforms: SumTree<Transform>,
  43    interpolated: bool,
  44}
  45
  46impl std::ops::Deref for WrapSnapshot {
  47    type Target = TabSnapshot;
  48
  49    fn deref(&self) -> &Self::Target {
  50        &self.tab_snapshot
  51    }
  52}
  53
  54#[derive(Clone, Debug, Default, Eq, PartialEq)]
  55struct Transform {
  56    summary: TransformSummary,
  57    display_text: Option<&'static str>,
  58}
  59
  60#[derive(Clone, Debug, Default, Eq, PartialEq)]
  61struct TransformSummary {
  62    input: TextSummary,
  63    output: TextSummary,
  64}
  65
  66#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
  67pub struct WrapPoint(pub Point);
  68
  69pub struct WrapChunks<'a> {
  70    input_chunks: tab_map::TabChunks<'a>,
  71    input_chunk: Chunk<'a>,
  72    output_position: WrapPoint,
  73    max_output_row: WrapRow,
  74    transforms: Cursor<'a, 'static, Transform, Dimensions<WrapPoint, TabPoint>>,
  75    snapshot: &'a WrapSnapshot,
  76}
  77
  78#[derive(Clone)]
  79pub struct WrapRows<'a> {
  80    input_buffer_rows: FoldRows<'a>,
  81    input_buffer_row: RowInfo,
  82    output_row: WrapRow,
  83    soft_wrapped: bool,
  84    max_output_row: WrapRow,
  85    transforms: Cursor<'a, 'static, Transform, Dimensions<WrapPoint, TabPoint>>,
  86}
  87
  88impl WrapRows<'_> {
  89    pub(crate) fn seek(&mut self, start_row: WrapRow) {
  90        self.transforms
  91            .seek(&WrapPoint::new(start_row, 0), Bias::Left);
  92        let mut input_row = self.transforms.start().1.row();
  93        if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
  94            input_row += (start_row - self.transforms.start().0.row()).0;
  95        }
  96        self.soft_wrapped = self.transforms.item().is_some_and(|t| !t.is_isomorphic());
  97        self.input_buffer_rows.seek(input_row);
  98        self.input_buffer_row = self.input_buffer_rows.next().unwrap();
  99        self.output_row = start_row;
 100    }
 101}
 102
 103impl WrapMap {
 104    pub fn new(
 105        tab_snapshot: TabSnapshot,
 106        font: Font,
 107        font_size: Pixels,
 108        wrap_width: Option<Pixels>,
 109        cx: &mut App,
 110    ) -> (Entity<Self>, WrapSnapshot) {
 111        let handle = cx.new(|cx| {
 112            let mut this = Self {
 113                font_with_size: (font, font_size),
 114                wrap_width: None,
 115                pending_edits: Default::default(),
 116                interpolated_edits: Default::default(),
 117                edits_since_sync: Default::default(),
 118                snapshot: WrapSnapshot::new(tab_snapshot),
 119                background_task: None,
 120            };
 121            this.set_wrap_width(wrap_width, cx);
 122            mem::take(&mut this.edits_since_sync);
 123            this
 124        });
 125        let snapshot = handle.read(cx).snapshot.clone();
 126        (handle, snapshot)
 127    }
 128
 129    #[cfg(test)]
 130    pub fn is_rewrapping(&self) -> bool {
 131        self.background_task.is_some()
 132    }
 133
 134    pub fn sync(
 135        &mut self,
 136        tab_snapshot: TabSnapshot,
 137        edits: Vec<TabEdit>,
 138        cx: &mut Context<Self>,
 139    ) -> (WrapSnapshot, WrapPatch) {
 140        if self.wrap_width.is_some() {
 141            self.pending_edits.push_back((tab_snapshot, edits));
 142            self.flush_edits(cx);
 143        } else {
 144            self.edits_since_sync = self
 145                .edits_since_sync
 146                .compose(self.snapshot.interpolate(tab_snapshot, &edits));
 147            self.snapshot.interpolated = false;
 148        }
 149
 150        (self.snapshot.clone(), mem::take(&mut self.edits_since_sync))
 151    }
 152
 153    pub fn set_font_with_size(
 154        &mut self,
 155        font: Font,
 156        font_size: Pixels,
 157        cx: &mut Context<Self>,
 158    ) -> bool {
 159        let font_with_size = (font, font_size);
 160
 161        if font_with_size == self.font_with_size {
 162            false
 163        } else {
 164            self.font_with_size = font_with_size;
 165            self.rewrap(cx);
 166            true
 167        }
 168    }
 169
 170    pub fn set_wrap_width(&mut self, wrap_width: Option<Pixels>, cx: &mut Context<Self>) -> bool {
 171        if wrap_width == self.wrap_width {
 172            return false;
 173        }
 174
 175        self.wrap_width = wrap_width;
 176        self.rewrap(cx);
 177        true
 178    }
 179
 180    fn rewrap(&mut self, cx: &mut Context<Self>) {
 181        self.background_task.take();
 182        self.interpolated_edits.clear();
 183        self.pending_edits.clear();
 184
 185        if let Some(wrap_width) = self.wrap_width {
 186            let mut new_snapshot = self.snapshot.clone();
 187
 188            let text_system = cx.text_system().clone();
 189            let (font, font_size) = self.font_with_size.clone();
 190            let task = cx.background_spawn(async move {
 191                let mut line_wrapper = text_system.line_wrapper(font, font_size);
 192                let tab_snapshot = new_snapshot.tab_snapshot.clone();
 193                let range = TabPoint::zero()..tab_snapshot.max_point();
 194                let edits = new_snapshot
 195                    .update(
 196                        tab_snapshot,
 197                        &[TabEdit {
 198                            old: range.clone(),
 199                            new: range.clone(),
 200                        }],
 201                        wrap_width,
 202                        &mut line_wrapper,
 203                    )
 204                    .await;
 205                (new_snapshot, edits)
 206            });
 207
 208            match cx
 209                .background_executor()
 210                .block_with_timeout(Duration::from_millis(5), task)
 211            {
 212                Ok((snapshot, edits)) => {
 213                    self.snapshot = snapshot;
 214                    self.edits_since_sync = self.edits_since_sync.compose(&edits);
 215                }
 216                Err(wrap_task) => {
 217                    self.background_task = Some(cx.spawn(async move |this, cx| {
 218                        let (snapshot, edits) = wrap_task.await;
 219                        this.update(cx, |this, cx| {
 220                            this.snapshot = snapshot;
 221                            this.edits_since_sync = this
 222                                .edits_since_sync
 223                                .compose(mem::take(&mut this.interpolated_edits).invert())
 224                                .compose(&edits);
 225                            this.background_task = None;
 226                            this.flush_edits(cx);
 227                            cx.notify();
 228                        })
 229                        .ok();
 230                    }));
 231                }
 232            }
 233        } else {
 234            let old_rows = self.snapshot.transforms.summary().output.lines.row + 1;
 235            self.snapshot.transforms = SumTree::default();
 236            let summary = self.snapshot.tab_snapshot.text_summary();
 237            if !summary.lines.is_zero() {
 238                self.snapshot
 239                    .transforms
 240                    .push(Transform::isomorphic(summary), ());
 241            }
 242            let new_rows = self.snapshot.transforms.summary().output.lines.row + 1;
 243            self.snapshot.interpolated = false;
 244            self.edits_since_sync = self.edits_since_sync.compose(Patch::new(vec![WrapEdit {
 245                old: WrapRow(0)..WrapRow(old_rows),
 246                new: WrapRow(0)..WrapRow(new_rows),
 247            }]));
 248        }
 249    }
 250
 251    fn flush_edits(&mut self, cx: &mut Context<Self>) {
 252        if !self.snapshot.interpolated {
 253            let mut to_remove_len = 0;
 254            for (tab_snapshot, _) in &self.pending_edits {
 255                if tab_snapshot.version <= self.snapshot.tab_snapshot.version {
 256                    to_remove_len += 1;
 257                } else {
 258                    break;
 259                }
 260            }
 261            self.pending_edits.drain(..to_remove_len);
 262        }
 263
 264        if self.pending_edits.is_empty() {
 265            return;
 266        }
 267
 268        if let Some(wrap_width) = self.wrap_width
 269            && self.background_task.is_none()
 270        {
 271            let pending_edits = self.pending_edits.clone();
 272            let mut snapshot = self.snapshot.clone();
 273            let text_system = cx.text_system().clone();
 274            let (font, font_size) = self.font_with_size.clone();
 275            let update_task = cx.background_spawn(async move {
 276                let mut edits = Patch::default();
 277                let mut line_wrapper = text_system.line_wrapper(font, font_size);
 278                for (tab_snapshot, tab_edits) in pending_edits {
 279                    let wrap_edits = snapshot
 280                        .update(tab_snapshot, &tab_edits, wrap_width, &mut line_wrapper)
 281                        .await;
 282                    edits = edits.compose(&wrap_edits);
 283                }
 284                (snapshot, edits)
 285            });
 286
 287            match cx
 288                .background_executor()
 289                .block_with_timeout(Duration::from_millis(1), update_task)
 290            {
 291                Ok((snapshot, output_edits)) => {
 292                    self.snapshot = snapshot;
 293                    self.edits_since_sync = self.edits_since_sync.compose(&output_edits);
 294                }
 295                Err(update_task) => {
 296                    self.background_task = Some(cx.spawn(async move |this, cx| {
 297                        let (snapshot, edits) = update_task.await;
 298                        this.update(cx, |this, cx| {
 299                            this.snapshot = snapshot;
 300                            this.edits_since_sync = this
 301                                .edits_since_sync
 302                                .compose(mem::take(&mut this.interpolated_edits).invert())
 303                                .compose(&edits);
 304                            this.background_task = None;
 305                            this.flush_edits(cx);
 306                            cx.notify();
 307                        })
 308                        .ok();
 309                    }));
 310                }
 311            }
 312        }
 313
 314        let was_interpolated = self.snapshot.interpolated;
 315        let mut to_remove_len = 0;
 316        for (tab_snapshot, edits) in &self.pending_edits {
 317            if tab_snapshot.version <= self.snapshot.tab_snapshot.version {
 318                to_remove_len += 1;
 319            } else {
 320                let interpolated_edits = self.snapshot.interpolate(tab_snapshot.clone(), edits);
 321                self.edits_since_sync = self.edits_since_sync.compose(&interpolated_edits);
 322                self.interpolated_edits = self.interpolated_edits.compose(&interpolated_edits);
 323            }
 324        }
 325
 326        if !was_interpolated {
 327            self.pending_edits.drain(..to_remove_len);
 328        }
 329    }
 330}
 331
 332impl WrapSnapshot {
 333    fn new(tab_snapshot: TabSnapshot) -> Self {
 334        let mut transforms = SumTree::default();
 335        let extent = tab_snapshot.text_summary();
 336        if !extent.lines.is_zero() {
 337            transforms.push(Transform::isomorphic(extent), ());
 338        }
 339        Self {
 340            transforms,
 341            tab_snapshot,
 342            interpolated: true,
 343        }
 344    }
 345
 346    pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot {
 347        self.tab_snapshot.buffer_snapshot()
 348    }
 349
 350    fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, tab_edits: &[TabEdit]) -> WrapPatch {
 351        let mut new_transforms;
 352        if tab_edits.is_empty() {
 353            new_transforms = self.transforms.clone();
 354        } else {
 355            let mut old_cursor = self.transforms.cursor::<TabPoint>(());
 356
 357            let mut tab_edits_iter = tab_edits.iter().peekable();
 358            new_transforms =
 359                old_cursor.slice(&tab_edits_iter.peek().unwrap().old.start, Bias::Right);
 360
 361            while let Some(edit) = tab_edits_iter.next() {
 362                if edit.new.start > TabPoint::from(new_transforms.summary().input.lines) {
 363                    let summary = new_tab_snapshot.text_summary_for_range(
 364                        TabPoint::from(new_transforms.summary().input.lines)..edit.new.start,
 365                    );
 366                    new_transforms.push_or_extend(Transform::isomorphic(summary));
 367                }
 368
 369                if !edit.new.is_empty() {
 370                    new_transforms.push_or_extend(Transform::isomorphic(
 371                        new_tab_snapshot.text_summary_for_range(edit.new.clone()),
 372                    ));
 373                }
 374
 375                old_cursor.seek_forward(&edit.old.end, Bias::Right);
 376                if let Some(next_edit) = tab_edits_iter.peek() {
 377                    if next_edit.old.start > old_cursor.end() {
 378                        if old_cursor.end() > edit.old.end {
 379                            let summary = self
 380                                .tab_snapshot
 381                                .text_summary_for_range(edit.old.end..old_cursor.end());
 382                            new_transforms.push_or_extend(Transform::isomorphic(summary));
 383                        }
 384
 385                        old_cursor.next();
 386                        new_transforms
 387                            .append(old_cursor.slice(&next_edit.old.start, Bias::Right), ());
 388                    }
 389                } else {
 390                    if old_cursor.end() > edit.old.end {
 391                        let summary = self
 392                            .tab_snapshot
 393                            .text_summary_for_range(edit.old.end..old_cursor.end());
 394                        new_transforms.push_or_extend(Transform::isomorphic(summary));
 395                    }
 396                    old_cursor.next();
 397                    new_transforms.append(old_cursor.suffix(), ());
 398                }
 399            }
 400        }
 401
 402        let old_snapshot = mem::replace(
 403            self,
 404            WrapSnapshot {
 405                tab_snapshot: new_tab_snapshot,
 406                transforms: new_transforms,
 407                interpolated: true,
 408            },
 409        );
 410        self.check_invariants();
 411        old_snapshot.compute_edits(tab_edits, self)
 412    }
 413
 414    async fn update(
 415        &mut self,
 416        new_tab_snapshot: TabSnapshot,
 417        tab_edits: &[TabEdit],
 418        wrap_width: Pixels,
 419        line_wrapper: &mut LineWrapper,
 420    ) -> WrapPatch {
 421        #[derive(Debug)]
 422        struct RowEdit {
 423            old_rows: Range<u32>,
 424            new_rows: Range<u32>,
 425        }
 426
 427        let mut tab_edits_iter = tab_edits.iter().peekable();
 428        let mut row_edits = Vec::with_capacity(tab_edits.len());
 429        while let Some(edit) = tab_edits_iter.next() {
 430            let mut row_edit = RowEdit {
 431                old_rows: edit.old.start.row()..edit.old.end.row() + 1,
 432                new_rows: edit.new.start.row()..edit.new.end.row() + 1,
 433            };
 434
 435            while let Some(next_edit) = tab_edits_iter.peek() {
 436                if next_edit.old.start.row() <= row_edit.old_rows.end {
 437                    row_edit.old_rows.end = next_edit.old.end.row() + 1;
 438                    row_edit.new_rows.end = next_edit.new.end.row() + 1;
 439                    tab_edits_iter.next();
 440                } else {
 441                    break;
 442                }
 443            }
 444
 445            row_edits.push(row_edit);
 446        }
 447
 448        let mut new_transforms;
 449        if row_edits.is_empty() {
 450            new_transforms = self.transforms.clone();
 451        } else {
 452            let mut row_edits = row_edits.into_iter().peekable();
 453            let mut old_cursor = self.transforms.cursor::<TabPoint>(());
 454
 455            new_transforms = old_cursor.slice(
 456                &TabPoint::new(row_edits.peek().unwrap().old_rows.start, 0),
 457                Bias::Right,
 458            );
 459
 460            while let Some(edit) = row_edits.next() {
 461                if edit.new_rows.start > new_transforms.summary().input.lines.row {
 462                    let summary = new_tab_snapshot.text_summary_for_range(
 463                        TabPoint(new_transforms.summary().input.lines)
 464                            ..TabPoint::new(edit.new_rows.start, 0),
 465                    );
 466                    new_transforms.push_or_extend(Transform::isomorphic(summary));
 467                }
 468
 469                let mut line = String::new();
 470                let mut line_fragments = Vec::new();
 471                let mut remaining = None;
 472                let mut chunks = new_tab_snapshot.chunks(
 473                    TabPoint::new(edit.new_rows.start, 0)..new_tab_snapshot.max_point(),
 474                    false,
 475                    Highlights::default(),
 476                );
 477                let mut edit_transforms = Vec::<Transform>::new();
 478                for _ in edit.new_rows.start..edit.new_rows.end {
 479                    while let Some(chunk) = remaining.take().or_else(|| chunks.next()) {
 480                        if let Some(ix) = chunk.text.find('\n') {
 481                            let (prefix, suffix) = chunk.text.split_at(ix + 1);
 482                            line_fragments.push(gpui::LineFragment::text(prefix));
 483                            line.push_str(prefix);
 484                            remaining = Some(Chunk {
 485                                text: suffix,
 486                                ..chunk
 487                            });
 488                            break;
 489                        } else {
 490                            if let Some(width) =
 491                                chunk.renderer.as_ref().and_then(|r| r.measured_width)
 492                            {
 493                                line_fragments
 494                                    .push(gpui::LineFragment::element(width, chunk.text.len()));
 495                            } else {
 496                                line_fragments.push(gpui::LineFragment::text(chunk.text));
 497                            }
 498                            line.push_str(chunk.text);
 499                        }
 500                    }
 501
 502                    if line.is_empty() {
 503                        break;
 504                    }
 505
 506                    let mut prev_boundary_ix = 0;
 507                    for boundary in line_wrapper.wrap_line(&line_fragments, wrap_width) {
 508                        let wrapped = &line[prev_boundary_ix..boundary.ix];
 509                        push_isomorphic(&mut edit_transforms, TextSummary::from(wrapped));
 510                        edit_transforms.push(Transform::wrap(boundary.next_indent));
 511                        prev_boundary_ix = boundary.ix;
 512                    }
 513
 514                    if prev_boundary_ix < line.len() {
 515                        push_isomorphic(
 516                            &mut edit_transforms,
 517                            TextSummary::from(&line[prev_boundary_ix..]),
 518                        );
 519                    }
 520
 521                    line.clear();
 522                    line_fragments.clear();
 523                    yield_now().await;
 524                }
 525
 526                let mut edit_transforms = edit_transforms.into_iter();
 527                if let Some(transform) = edit_transforms.next() {
 528                    new_transforms.push_or_extend(transform);
 529                }
 530                new_transforms.extend(edit_transforms, ());
 531
 532                old_cursor.seek_forward(&TabPoint::new(edit.old_rows.end, 0), Bias::Right);
 533                if let Some(next_edit) = row_edits.peek() {
 534                    if next_edit.old_rows.start > old_cursor.end().row() {
 535                        if old_cursor.end() > TabPoint::new(edit.old_rows.end, 0) {
 536                            let summary = self.tab_snapshot.text_summary_for_range(
 537                                TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(),
 538                            );
 539                            new_transforms.push_or_extend(Transform::isomorphic(summary));
 540                        }
 541                        old_cursor.next();
 542                        new_transforms.append(
 543                            old_cursor
 544                                .slice(&TabPoint::new(next_edit.old_rows.start, 0), Bias::Right),
 545                            (),
 546                        );
 547                    }
 548                } else {
 549                    if old_cursor.end() > TabPoint::new(edit.old_rows.end, 0) {
 550                        let summary = self.tab_snapshot.text_summary_for_range(
 551                            TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(),
 552                        );
 553                        new_transforms.push_or_extend(Transform::isomorphic(summary));
 554                    }
 555                    old_cursor.next();
 556                    new_transforms.append(old_cursor.suffix(), ());
 557                }
 558            }
 559        }
 560
 561        let old_snapshot = mem::replace(
 562            self,
 563            WrapSnapshot {
 564                tab_snapshot: new_tab_snapshot,
 565                transforms: new_transforms,
 566                interpolated: false,
 567            },
 568        );
 569        self.check_invariants();
 570        old_snapshot.compute_edits(tab_edits, self)
 571    }
 572
 573    fn compute_edits(&self, tab_edits: &[TabEdit], new_snapshot: &WrapSnapshot) -> WrapPatch {
 574        let mut wrap_edits = Vec::with_capacity(tab_edits.len());
 575        let mut old_cursor = self.transforms.cursor::<TransformSummary>(());
 576        let mut new_cursor = new_snapshot.transforms.cursor::<TransformSummary>(());
 577        for mut tab_edit in tab_edits.iter().cloned() {
 578            tab_edit.old.start.0.column = 0;
 579            tab_edit.old.end.0 += Point::new(1, 0);
 580            tab_edit.new.start.0.column = 0;
 581            tab_edit.new.end.0 += Point::new(1, 0);
 582
 583            old_cursor.seek(&tab_edit.old.start, Bias::Right);
 584            let mut old_start = old_cursor.start().output.lines;
 585            old_start += tab_edit.old.start.0 - old_cursor.start().input.lines;
 586
 587            old_cursor.seek_forward(&tab_edit.old.end, Bias::Right);
 588            let mut old_end = old_cursor.start().output.lines;
 589            old_end += tab_edit.old.end.0 - old_cursor.start().input.lines;
 590
 591            new_cursor.seek(&tab_edit.new.start, Bias::Right);
 592            let mut new_start = new_cursor.start().output.lines;
 593            new_start += tab_edit.new.start.0 - new_cursor.start().input.lines;
 594
 595            new_cursor.seek_forward(&tab_edit.new.end, Bias::Right);
 596            let mut new_end = new_cursor.start().output.lines;
 597            new_end += tab_edit.new.end.0 - new_cursor.start().input.lines;
 598
 599            wrap_edits.push(WrapEdit {
 600                old: WrapRow(old_start.row)..WrapRow(old_end.row),
 601                new: WrapRow(new_start.row)..WrapRow(new_end.row),
 602            });
 603        }
 604
 605        wrap_edits = consolidate_wrap_edits(wrap_edits);
 606        Patch::new(wrap_edits)
 607    }
 608
 609    pub(crate) fn chunks<'a>(
 610        &'a self,
 611        rows: Range<WrapRow>,
 612        language_aware: bool,
 613        highlights: Highlights<'a>,
 614    ) -> WrapChunks<'a> {
 615        let output_start = WrapPoint::new(rows.start, 0);
 616        let output_end = WrapPoint::new(rows.end, 0);
 617        let mut transforms = self
 618            .transforms
 619            .cursor::<Dimensions<WrapPoint, TabPoint>>(());
 620        transforms.seek(&output_start, Bias::Right);
 621        let mut input_start = TabPoint(transforms.start().1.0);
 622        if transforms.item().is_some_and(|t| t.is_isomorphic()) {
 623            input_start.0 += output_start.0 - transforms.start().0.0;
 624        }
 625        let input_end = self
 626            .to_tab_point(output_end)
 627            .min(self.tab_snapshot.max_point());
 628        WrapChunks {
 629            input_chunks: self.tab_snapshot.chunks(
 630                input_start..input_end,
 631                language_aware,
 632                highlights,
 633            ),
 634            input_chunk: Default::default(),
 635            output_position: output_start,
 636            max_output_row: rows.end,
 637            transforms,
 638            snapshot: self,
 639        }
 640    }
 641
 642    pub fn max_point(&self) -> WrapPoint {
 643        WrapPoint(self.transforms.summary().output.lines)
 644    }
 645
 646    pub fn line_len(&self, row: WrapRow) -> u32 {
 647        let (start, _, item) = self.transforms.find::<Dimensions<WrapPoint, TabPoint>, _>(
 648            (),
 649            &WrapPoint::new(row + WrapRow(1), 0),
 650            Bias::Left,
 651        );
 652        if item.is_some_and(|transform| transform.is_isomorphic()) {
 653            let overshoot = row - start.0.row();
 654            let tab_row = start.1.row() + overshoot.0;
 655            let tab_line_len = self.tab_snapshot.line_len(tab_row);
 656            if overshoot.0 == 0 {
 657                start.0.column() + (tab_line_len - start.1.column())
 658            } else {
 659                tab_line_len
 660            }
 661        } else {
 662            start.0.column()
 663        }
 664    }
 665
 666    pub fn text_summary_for_range(&self, rows: Range<WrapRow>) -> TextSummary {
 667        let mut summary = TextSummary::default();
 668
 669        let start = WrapPoint::new(rows.start, 0);
 670        let end = WrapPoint::new(rows.end, 0);
 671
 672        let mut cursor = self
 673            .transforms
 674            .cursor::<Dimensions<WrapPoint, TabPoint>>(());
 675        cursor.seek(&start, Bias::Right);
 676        if let Some(transform) = cursor.item() {
 677            let start_in_transform = start.0 - cursor.start().0.0;
 678            let end_in_transform = cmp::min(end, cursor.end().0).0 - cursor.start().0.0;
 679            if transform.is_isomorphic() {
 680                let tab_start = TabPoint(cursor.start().1.0 + start_in_transform);
 681                let tab_end = TabPoint(cursor.start().1.0 + end_in_transform);
 682                summary += &self.tab_snapshot.text_summary_for_range(tab_start..tab_end);
 683            } else {
 684                debug_assert_eq!(start_in_transform.row, end_in_transform.row);
 685                let indent_len = end_in_transform.column - start_in_transform.column;
 686                summary += &TextSummary {
 687                    lines: Point::new(0, indent_len),
 688                    first_line_chars: indent_len,
 689                    last_line_chars: indent_len,
 690                    longest_row: 0,
 691                    longest_row_chars: indent_len,
 692                };
 693            }
 694
 695            cursor.next();
 696        }
 697
 698        if rows.end > cursor.start().0.row() {
 699            summary += &cursor
 700                .summary::<_, TransformSummary>(&WrapPoint::new(rows.end, 0), Bias::Right)
 701                .output;
 702
 703            if let Some(transform) = cursor.item() {
 704                let end_in_transform = end.0 - cursor.start().0.0;
 705                if transform.is_isomorphic() {
 706                    let char_start = cursor.start().1;
 707                    let char_end = TabPoint(char_start.0 + end_in_transform);
 708                    summary += &self
 709                        .tab_snapshot
 710                        .text_summary_for_range(char_start..char_end);
 711                } else {
 712                    debug_assert_eq!(end_in_transform, Point::new(1, 0));
 713                    summary += &TextSummary {
 714                        lines: Point::new(1, 0),
 715                        first_line_chars: 0,
 716                        last_line_chars: 0,
 717                        longest_row: 0,
 718                        longest_row_chars: 0,
 719                    };
 720                }
 721            }
 722        }
 723
 724        summary
 725    }
 726
 727    pub fn soft_wrap_indent(&self, row: WrapRow) -> Option<u32> {
 728        let (.., item) = self.transforms.find::<WrapPoint, _>(
 729            (),
 730            &WrapPoint::new(row + WrapRow(1), 0),
 731            Bias::Right,
 732        );
 733        item.and_then(|transform| {
 734            if transform.is_isomorphic() {
 735                None
 736            } else {
 737                Some(transform.summary.output.lines.column)
 738            }
 739        })
 740    }
 741
 742    pub fn longest_row(&self) -> u32 {
 743        self.transforms.summary().output.longest_row
 744    }
 745
 746    pub fn row_infos(&self, start_row: WrapRow) -> WrapRows<'_> {
 747        let mut transforms = self
 748            .transforms
 749            .cursor::<Dimensions<WrapPoint, TabPoint>>(());
 750        transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left);
 751        let mut input_row = transforms.start().1.row();
 752        if transforms.item().is_some_and(|t| t.is_isomorphic()) {
 753            input_row += (start_row - transforms.start().0.row()).0;
 754        }
 755        let soft_wrapped = transforms.item().is_some_and(|t| !t.is_isomorphic());
 756        let mut input_buffer_rows = self.tab_snapshot.rows(input_row);
 757        let input_buffer_row = input_buffer_rows.next().unwrap();
 758        WrapRows {
 759            transforms,
 760            input_buffer_row,
 761            input_buffer_rows,
 762            output_row: start_row,
 763            soft_wrapped,
 764            max_output_row: self.max_point().row(),
 765        }
 766    }
 767
 768    pub fn to_tab_point(&self, point: WrapPoint) -> TabPoint {
 769        let (start, _, item) =
 770            self.transforms
 771                .find::<Dimensions<WrapPoint, TabPoint>, _>((), &point, Bias::Right);
 772        let mut tab_point = start.1.0;
 773        if item.is_some_and(|t| t.is_isomorphic()) {
 774            tab_point += point.0 - start.0.0;
 775        }
 776        TabPoint(tab_point)
 777    }
 778
 779    pub fn to_point(&self, point: WrapPoint, bias: Bias) -> Point {
 780        self.tab_snapshot.to_point(self.to_tab_point(point), bias)
 781    }
 782
 783    pub fn make_wrap_point(&self, point: Point, bias: Bias) -> WrapPoint {
 784        self.tab_point_to_wrap_point(self.tab_snapshot.make_tab_point(point, bias))
 785    }
 786
 787    pub fn tab_point_to_wrap_point(&self, point: TabPoint) -> WrapPoint {
 788        let (start, ..) =
 789            self.transforms
 790                .find::<Dimensions<TabPoint, WrapPoint>, _>((), &point, Bias::Right);
 791        WrapPoint(start.1.0 + (point.0 - start.0.0))
 792    }
 793
 794    pub fn clip_point(&self, mut point: WrapPoint, bias: Bias) -> WrapPoint {
 795        if bias == Bias::Left {
 796            let (start, _, item) = self
 797                .transforms
 798                .find::<WrapPoint, _>((), &point, Bias::Right);
 799            if item.is_some_and(|t| !t.is_isomorphic()) {
 800                point = start;
 801                *point.column_mut() -= 1;
 802            }
 803        }
 804
 805        self.tab_point_to_wrap_point(self.tab_snapshot.clip_point(self.to_tab_point(point), bias))
 806    }
 807
 808    pub fn prev_row_boundary(&self, mut point: WrapPoint) -> WrapRow {
 809        if self.transforms.is_empty() {
 810            return WrapRow(0);
 811        }
 812
 813        *point.column_mut() = 0;
 814
 815        let mut cursor = self
 816            .transforms
 817            .cursor::<Dimensions<WrapPoint, TabPoint>>(());
 818        cursor.seek(&point, Bias::Right);
 819        if cursor.item().is_none() {
 820            cursor.prev();
 821        }
 822
 823        while let Some(transform) = cursor.item() {
 824            if transform.is_isomorphic() && cursor.start().1.column() == 0 {
 825                return cmp::min(cursor.end().0.row(), point.row());
 826            } else {
 827                cursor.prev();
 828            }
 829        }
 830
 831        unreachable!()
 832    }
 833
 834    pub fn next_row_boundary(&self, mut point: WrapPoint) -> Option<WrapRow> {
 835        point.0 += Point::new(1, 0);
 836
 837        let mut cursor = self
 838            .transforms
 839            .cursor::<Dimensions<WrapPoint, TabPoint>>(());
 840        cursor.seek(&point, Bias::Right);
 841        while let Some(transform) = cursor.item() {
 842            if transform.is_isomorphic() && cursor.start().1.column() == 0 {
 843                return Some(cmp::max(cursor.start().0.row(), point.row()));
 844            } else {
 845                cursor.next();
 846            }
 847        }
 848
 849        None
 850    }
 851
 852    #[cfg(test)]
 853    pub fn text(&self) -> String {
 854        self.text_chunks(WrapRow(0)).collect()
 855    }
 856
 857    #[cfg(test)]
 858    pub fn text_chunks(&self, wrap_row: WrapRow) -> impl Iterator<Item = &str> {
 859        self.chunks(
 860            wrap_row..self.max_point().row() + WrapRow(1),
 861            false,
 862            Highlights::default(),
 863        )
 864        .map(|h| h.text)
 865    }
 866
 867    fn check_invariants(&self) {
 868        #[cfg(test)]
 869        {
 870            assert_eq!(
 871                TabPoint::from(self.transforms.summary().input.lines),
 872                self.tab_snapshot.max_point()
 873            );
 874
 875            {
 876                let mut transforms = self.transforms.cursor::<()>(()).peekable();
 877                while let Some(transform) = transforms.next() {
 878                    if let Some(next_transform) = transforms.peek() {
 879                        assert!(transform.is_isomorphic() != next_transform.is_isomorphic());
 880                    }
 881                }
 882            }
 883
 884            let text = language::Rope::from(self.text().as_str());
 885            let mut input_buffer_rows = self.tab_snapshot.rows(0);
 886            let mut expected_buffer_rows = Vec::new();
 887            let mut prev_tab_row = 0;
 888            for display_row in 0..=self.max_point().row().0 {
 889                let display_row = WrapRow(display_row);
 890                let tab_point = self.to_tab_point(WrapPoint::new(display_row, 0));
 891                if tab_point.row() == prev_tab_row && display_row != WrapRow(0) {
 892                    expected_buffer_rows.push(None);
 893                } else {
 894                    expected_buffer_rows.push(input_buffer_rows.next().unwrap().buffer_row);
 895                }
 896
 897                prev_tab_row = tab_point.row();
 898                assert_eq!(self.line_len(display_row), text.line_len(display_row.0));
 899            }
 900
 901            for start_display_row in 0..expected_buffer_rows.len() {
 902                assert_eq!(
 903                    self.row_infos(WrapRow(start_display_row as u32))
 904                        .map(|row_info| row_info.buffer_row)
 905                        .collect::<Vec<_>>(),
 906                    &expected_buffer_rows[start_display_row..],
 907                    "invalid buffer_rows({}..)",
 908                    start_display_row
 909                );
 910            }
 911        }
 912    }
 913}
 914
 915impl WrapChunks<'_> {
 916    pub(crate) fn seek(&mut self, rows: Range<WrapRow>) {
 917        let output_start = WrapPoint::new(rows.start, 0);
 918        let output_end = WrapPoint::new(rows.end, 0);
 919        self.transforms.seek(&output_start, Bias::Right);
 920        let mut input_start = TabPoint(self.transforms.start().1.0);
 921        if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
 922            input_start.0 += output_start.0 - self.transforms.start().0.0;
 923        }
 924        let input_end = self
 925            .snapshot
 926            .to_tab_point(output_end)
 927            .min(self.snapshot.tab_snapshot.max_point());
 928        self.input_chunks.seek(input_start..input_end);
 929        self.input_chunk = Chunk::default();
 930        self.output_position = output_start;
 931        self.max_output_row = rows.end;
 932    }
 933}
 934
 935impl<'a> Iterator for WrapChunks<'a> {
 936    type Item = Chunk<'a>;
 937
 938    fn next(&mut self) -> Option<Self::Item> {
 939        if self.output_position.row() >= self.max_output_row {
 940            return None;
 941        }
 942
 943        let transform = self.transforms.item()?;
 944        if let Some(display_text) = transform.display_text {
 945            let mut start_ix = 0;
 946            let mut end_ix = display_text.len();
 947            let mut summary = transform.summary.output.lines;
 948
 949            if self.output_position > self.transforms.start().0 {
 950                // Exclude newline starting prior to the desired row.
 951                start_ix = 1;
 952                summary.row = 0;
 953            } else if self.output_position.row() + WrapRow(1) >= self.max_output_row {
 954                // Exclude soft indentation ending after the desired row.
 955                end_ix = 1;
 956                summary.column = 0;
 957            }
 958
 959            self.output_position.0 += summary;
 960            self.transforms.next();
 961            return Some(Chunk {
 962                text: &display_text[start_ix..end_ix],
 963                ..Default::default()
 964            });
 965        }
 966
 967        if self.input_chunk.text.is_empty() {
 968            self.input_chunk = self.input_chunks.next().unwrap();
 969        }
 970
 971        let mut input_len = 0;
 972        let transform_end = self.transforms.end().0;
 973        for c in self.input_chunk.text.chars() {
 974            let char_len = c.len_utf8();
 975            input_len += char_len;
 976            if c == '\n' {
 977                *self.output_position.row_mut() += 1;
 978                *self.output_position.column_mut() = 0;
 979            } else {
 980                *self.output_position.column_mut() += char_len as u32;
 981            }
 982
 983            if self.output_position >= transform_end {
 984                self.transforms.next();
 985                break;
 986            }
 987        }
 988
 989        let (prefix, suffix) = self.input_chunk.text.split_at(input_len);
 990
 991        let mask = 1u128.unbounded_shl(input_len as u32).wrapping_sub(1);
 992        let chars = self.input_chunk.chars & mask;
 993        let tabs = self.input_chunk.tabs & mask;
 994        self.input_chunk.tabs = self.input_chunk.tabs.unbounded_shr(input_len as u32);
 995        self.input_chunk.chars = self.input_chunk.chars.unbounded_shr(input_len as u32);
 996
 997        self.input_chunk.text = suffix;
 998        Some(Chunk {
 999            text: prefix,
1000            chars,
1001            tabs,
1002            ..self.input_chunk.clone()
1003        })
1004    }
1005}
1006
1007impl Iterator for WrapRows<'_> {
1008    type Item = RowInfo;
1009
1010    fn next(&mut self) -> Option<Self::Item> {
1011        if self.output_row > self.max_output_row {
1012            return None;
1013        }
1014
1015        let buffer_row = self.input_buffer_row;
1016        let soft_wrapped = self.soft_wrapped;
1017        let diff_status = self.input_buffer_row.diff_status;
1018
1019        self.output_row += WrapRow(1);
1020        self.transforms
1021            .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left);
1022        if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
1023            self.input_buffer_row = self.input_buffer_rows.next().unwrap();
1024            self.soft_wrapped = false;
1025        } else {
1026            self.soft_wrapped = true;
1027        }
1028
1029        Some(if soft_wrapped {
1030            RowInfo {
1031                buffer_id: None,
1032                buffer_row: None,
1033                multibuffer_row: None,
1034                diff_status,
1035                expand_info: None,
1036                wrapped_buffer_row: buffer_row.buffer_row,
1037            }
1038        } else {
1039            buffer_row
1040        })
1041    }
1042}
1043
1044impl Transform {
1045    fn isomorphic(summary: TextSummary) -> Self {
1046        #[cfg(test)]
1047        assert!(!summary.lines.is_zero());
1048
1049        Self {
1050            summary: TransformSummary {
1051                input: summary.clone(),
1052                output: summary,
1053            },
1054            display_text: None,
1055        }
1056    }
1057
1058    fn wrap(indent: u32) -> Self {
1059        static WRAP_TEXT: LazyLock<String> = LazyLock::new(|| {
1060            let mut wrap_text = String::new();
1061            wrap_text.push('\n');
1062            wrap_text.extend((0..LineWrapper::MAX_INDENT as usize).map(|_| ' '));
1063            wrap_text
1064        });
1065
1066        Self {
1067            summary: TransformSummary {
1068                input: TextSummary::default(),
1069                output: TextSummary {
1070                    lines: Point::new(1, indent),
1071                    first_line_chars: 0,
1072                    last_line_chars: indent,
1073                    longest_row: 1,
1074                    longest_row_chars: indent,
1075                },
1076            },
1077            display_text: Some(&WRAP_TEXT[..1 + indent as usize]),
1078        }
1079    }
1080
1081    fn is_isomorphic(&self) -> bool {
1082        self.display_text.is_none()
1083    }
1084}
1085
1086impl sum_tree::Item for Transform {
1087    type Summary = TransformSummary;
1088
1089    fn summary(&self, _cx: ()) -> Self::Summary {
1090        self.summary.clone()
1091    }
1092}
1093
1094fn push_isomorphic(transforms: &mut Vec<Transform>, summary: TextSummary) {
1095    if let Some(last_transform) = transforms.last_mut()
1096        && last_transform.is_isomorphic()
1097    {
1098        last_transform.summary.input += &summary;
1099        last_transform.summary.output += &summary;
1100        return;
1101    }
1102    transforms.push(Transform::isomorphic(summary));
1103}
1104
1105trait SumTreeExt {
1106    fn push_or_extend(&mut self, transform: Transform);
1107}
1108
1109impl SumTreeExt for SumTree<Transform> {
1110    fn push_or_extend(&mut self, transform: Transform) {
1111        let mut transform = Some(transform);
1112        self.update_last(
1113            |last_transform| {
1114                if last_transform.is_isomorphic() && transform.as_ref().unwrap().is_isomorphic() {
1115                    let transform = transform.take().unwrap();
1116                    last_transform.summary.input += &transform.summary.input;
1117                    last_transform.summary.output += &transform.summary.output;
1118                }
1119            },
1120            (),
1121        );
1122
1123        if let Some(transform) = transform {
1124            self.push(transform, ());
1125        }
1126    }
1127}
1128
1129impl WrapPoint {
1130    pub fn new(row: WrapRow, column: u32) -> Self {
1131        Self(Point::new(row.0, column))
1132    }
1133
1134    pub fn row(self) -> WrapRow {
1135        WrapRow(self.0.row)
1136    }
1137
1138    pub fn row_mut(&mut self) -> &mut u32 {
1139        &mut self.0.row
1140    }
1141
1142    pub fn column(self) -> u32 {
1143        self.0.column
1144    }
1145
1146    pub fn column_mut(&mut self) -> &mut u32 {
1147        &mut self.0.column
1148    }
1149}
1150
1151impl sum_tree::ContextLessSummary for TransformSummary {
1152    fn zero() -> Self {
1153        Default::default()
1154    }
1155
1156    fn add_summary(&mut self, other: &Self) {
1157        self.input += &other.input;
1158        self.output += &other.output;
1159    }
1160}
1161
1162impl<'a> sum_tree::Dimension<'a, TransformSummary> for TabPoint {
1163    fn zero(_cx: ()) -> Self {
1164        Default::default()
1165    }
1166
1167    fn add_summary(&mut self, summary: &'a TransformSummary, _: ()) {
1168        self.0 += summary.input.lines;
1169    }
1170}
1171
1172impl sum_tree::SeekTarget<'_, TransformSummary, TransformSummary> for TabPoint {
1173    fn cmp(&self, cursor_location: &TransformSummary, _: ()) -> std::cmp::Ordering {
1174        Ord::cmp(&self.0, &cursor_location.input.lines)
1175    }
1176}
1177
1178impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapPoint {
1179    fn zero(_cx: ()) -> Self {
1180        Default::default()
1181    }
1182
1183    fn add_summary(&mut self, summary: &'a TransformSummary, _: ()) {
1184        self.0 += summary.output.lines;
1185    }
1186}
1187
1188fn consolidate_wrap_edits(edits: Vec<WrapEdit>) -> Vec<WrapEdit> {
1189    let _old_alloc_ptr = edits.as_ptr();
1190    let mut wrap_edits = edits.into_iter();
1191
1192    if let Some(mut first_edit) = wrap_edits.next() {
1193        // This code relies on reusing allocations from the Vec<_> - at the time of writing .flatten() prevents them.
1194        #[allow(clippy::filter_map_identity)]
1195        let mut v: Vec<_> = wrap_edits
1196            .scan(&mut first_edit, |prev_edit, edit| {
1197                if prev_edit.old.end >= edit.old.start {
1198                    prev_edit.old.end = edit.old.end;
1199                    prev_edit.new.end = edit.new.end;
1200                    Some(None) // Skip this edit, it's merged
1201                } else {
1202                    let prev = std::mem::replace(*prev_edit, edit);
1203                    Some(Some(prev)) // Yield the previous edit
1204                }
1205            })
1206            .filter_map(|x| x)
1207            .collect();
1208        v.push(first_edit.clone());
1209        debug_assert_eq!(v.as_ptr(), _old_alloc_ptr, "Wrap edits were reallocated");
1210        v
1211    } else {
1212        vec![]
1213    }
1214}
1215
1216#[cfg(test)]
1217mod tests {
1218    use super::*;
1219    use crate::{
1220        MultiBuffer,
1221        display_map::{fold_map::FoldMap, inlay_map::InlayMap, tab_map::TabMap},
1222        test::test_font,
1223    };
1224    use gpui::{LineFragment, px, test::observe};
1225    use rand::prelude::*;
1226    use settings::SettingsStore;
1227    use smol::stream::StreamExt;
1228    use std::{cmp, env, num::NonZeroU32};
1229    use text::Rope;
1230    use theme::LoadThemes;
1231
1232    #[gpui::test(iterations = 100)]
1233    async fn test_random_wraps(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
1234        // todo this test is flaky
1235        init_test(cx);
1236
1237        cx.background_executor.set_block_on_ticks(0..=50);
1238        let operations = env::var("OPERATIONS")
1239            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1240            .unwrap_or(10);
1241
1242        let text_system = cx.read(|cx| cx.text_system().clone());
1243        let mut wrap_width = if rng.random_bool(0.1) {
1244            None
1245        } else {
1246            Some(px(rng.random_range(0.0..=1000.0)))
1247        };
1248        let tab_size = NonZeroU32::new(rng.random_range(1..=4)).unwrap();
1249
1250        let font = test_font();
1251        let _font_id = text_system.resolve_font(&font);
1252        let font_size = px(14.0);
1253
1254        log::info!("Tab size: {}", tab_size);
1255        log::info!("Wrap width: {:?}", wrap_width);
1256
1257        let buffer = cx.update(|cx| {
1258            if rng.random() {
1259                MultiBuffer::build_random(&mut rng, cx)
1260            } else {
1261                let len = rng.random_range(0..10);
1262                let text = util::RandomCharIter::new(&mut rng)
1263                    .take(len)
1264                    .collect::<String>();
1265                MultiBuffer::build_simple(&text, cx)
1266            }
1267        });
1268        let mut buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
1269        log::info!("Buffer text: {:?}", buffer_snapshot.text());
1270        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
1271        log::info!("InlayMap text: {:?}", inlay_snapshot.text());
1272        let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot.clone());
1273        log::info!("FoldMap text: {:?}", fold_snapshot.text());
1274        let (mut tab_map, _) = TabMap::new(fold_snapshot.clone(), tab_size);
1275        let tabs_snapshot = tab_map.set_max_expansion_column(32);
1276        log::info!("TabMap text: {:?}", tabs_snapshot.text());
1277
1278        let mut line_wrapper = text_system.line_wrapper(font.clone(), font_size);
1279        let expected_text = wrap_text(&tabs_snapshot, wrap_width, &mut line_wrapper);
1280
1281        let (wrap_map, _) =
1282            cx.update(|cx| WrapMap::new(tabs_snapshot.clone(), font, font_size, wrap_width, cx));
1283        let mut notifications = observe(&wrap_map, cx);
1284
1285        if wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1286            notifications.next().await.unwrap();
1287        }
1288
1289        let (initial_snapshot, _) = wrap_map.update(cx, |map, cx| {
1290            assert!(!map.is_rewrapping());
1291            map.sync(tabs_snapshot.clone(), Vec::new(), cx)
1292        });
1293
1294        let actual_text = initial_snapshot.text();
1295        assert_eq!(
1296            actual_text,
1297            expected_text,
1298            "unwrapped text is: {:?}",
1299            tabs_snapshot.text()
1300        );
1301        log::info!("Wrapped text: {:?}", actual_text);
1302
1303        let mut next_inlay_id = 0;
1304        let mut edits = Vec::new();
1305        for _i in 0..operations {
1306            log::info!("{} ==============================================", _i);
1307
1308            let mut buffer_edits = Vec::new();
1309            match rng.random_range(0..=100) {
1310                0..=19 => {
1311                    wrap_width = if rng.random_bool(0.2) {
1312                        None
1313                    } else {
1314                        Some(px(rng.random_range(0.0..=1000.0)))
1315                    };
1316                    log::info!("Setting wrap width to {:?}", wrap_width);
1317                    wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
1318                }
1319                20..=39 => {
1320                    for (fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) {
1321                        let (tabs_snapshot, tab_edits) =
1322                            tab_map.sync(fold_snapshot, fold_edits, tab_size);
1323                        let (mut snapshot, wrap_edits) =
1324                            wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
1325                        snapshot.check_invariants();
1326                        snapshot.verify_chunks(&mut rng);
1327                        edits.push((snapshot, wrap_edits));
1328                    }
1329                }
1330                40..=59 => {
1331                    let (inlay_snapshot, inlay_edits) =
1332                        inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng);
1333                    let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
1334                    let (tabs_snapshot, tab_edits) =
1335                        tab_map.sync(fold_snapshot, fold_edits, tab_size);
1336                    let (mut snapshot, wrap_edits) =
1337                        wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
1338                    snapshot.check_invariants();
1339                    snapshot.verify_chunks(&mut rng);
1340                    edits.push((snapshot, wrap_edits));
1341                }
1342                _ => {
1343                    buffer.update(cx, |buffer, cx| {
1344                        let subscription = buffer.subscribe();
1345                        let edit_count = rng.random_range(1..=5);
1346                        buffer.randomly_mutate(&mut rng, edit_count, cx);
1347                        buffer_snapshot = buffer.snapshot(cx);
1348                        buffer_edits.extend(subscription.consume());
1349                    });
1350                }
1351            }
1352
1353            log::info!("Buffer text: {:?}", buffer_snapshot.text());
1354            let (inlay_snapshot, inlay_edits) =
1355                inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
1356            log::info!("InlayMap text: {:?}", inlay_snapshot.text());
1357            let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
1358            log::info!("FoldMap text: {:?}", fold_snapshot.text());
1359            let (tabs_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
1360            log::info!("TabMap text: {:?}", tabs_snapshot.text());
1361
1362            let expected_text = wrap_text(&tabs_snapshot, wrap_width, &mut line_wrapper);
1363            let (mut snapshot, wrap_edits) =
1364                wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot.clone(), tab_edits, cx));
1365            snapshot.check_invariants();
1366            snapshot.verify_chunks(&mut rng);
1367            edits.push((snapshot, wrap_edits));
1368
1369            if wrap_map.read_with(cx, |map, _| map.is_rewrapping()) && rng.random_bool(0.4) {
1370                log::info!("Waiting for wrapping to finish");
1371                while wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1372                    notifications.next().await.unwrap();
1373                }
1374                wrap_map.read_with(cx, |map, _| assert!(map.pending_edits.is_empty()));
1375            }
1376
1377            if !wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1378                let (mut wrapped_snapshot, wrap_edits) = wrap_map.update(cx, |map, cx| {
1379                    map.sync(tabs_snapshot.clone(), Vec::new(), cx)
1380                });
1381                let actual_text = wrapped_snapshot.text();
1382                let actual_longest_row = wrapped_snapshot.longest_row();
1383                log::info!("Wrapping finished: {:?}", actual_text);
1384                wrapped_snapshot.check_invariants();
1385                wrapped_snapshot.verify_chunks(&mut rng);
1386                edits.push((wrapped_snapshot.clone(), wrap_edits));
1387                assert_eq!(
1388                    actual_text,
1389                    expected_text,
1390                    "unwrapped text is: {:?}",
1391                    tabs_snapshot.text()
1392                );
1393
1394                let mut summary = TextSummary::default();
1395                for (ix, item) in wrapped_snapshot
1396                    .transforms
1397                    .items(())
1398                    .into_iter()
1399                    .enumerate()
1400                {
1401                    summary += &item.summary.output;
1402                    log::info!("{} summary: {:?}", ix, item.summary.output,);
1403                }
1404
1405                if tab_size.get() == 1
1406                    || !wrapped_snapshot
1407                        .tab_snapshot
1408                        .fold_snapshot
1409                        .text()
1410                        .contains('\t')
1411                {
1412                    let mut expected_longest_rows = Vec::new();
1413                    let mut longest_line_len = -1;
1414                    for (row, line) in expected_text.split('\n').enumerate() {
1415                        let line_char_count = line.chars().count() as isize;
1416                        if line_char_count > longest_line_len {
1417                            expected_longest_rows.clear();
1418                            longest_line_len = line_char_count;
1419                        }
1420                        if line_char_count >= longest_line_len {
1421                            expected_longest_rows.push(row as u32);
1422                        }
1423                    }
1424
1425                    assert!(
1426                        expected_longest_rows.contains(&actual_longest_row),
1427                        "incorrect longest row {}. expected {:?} with length {}",
1428                        actual_longest_row,
1429                        expected_longest_rows,
1430                        longest_line_len,
1431                    )
1432                }
1433            }
1434        }
1435
1436        let mut initial_text = Rope::from(initial_snapshot.text().as_str());
1437        for (snapshot, patch) in edits {
1438            let snapshot_text = Rope::from(snapshot.text().as_str());
1439            for edit in &patch {
1440                let old_start = initial_text.point_to_offset(Point::new(edit.new.start.0, 0));
1441                let old_end = initial_text.point_to_offset(cmp::min(
1442                    Point::new(edit.new.start.0 + (edit.old.end - edit.old.start).0, 0),
1443                    initial_text.max_point(),
1444                ));
1445                let new_start = snapshot_text.point_to_offset(Point::new(edit.new.start.0, 0));
1446                let new_end = snapshot_text.point_to_offset(cmp::min(
1447                    Point::new(edit.new.end.0, 0),
1448                    snapshot_text.max_point(),
1449                ));
1450                let new_text = snapshot_text
1451                    .chunks_in_range(new_start..new_end)
1452                    .collect::<String>();
1453
1454                initial_text.replace(old_start..old_end, &new_text);
1455            }
1456            assert_eq!(initial_text.to_string(), snapshot_text.to_string());
1457        }
1458
1459        if wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1460            log::info!("Waiting for wrapping to finish");
1461            while wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1462                notifications.next().await.unwrap();
1463            }
1464        }
1465        wrap_map.read_with(cx, |map, _| assert!(map.pending_edits.is_empty()));
1466    }
1467
1468    fn init_test(cx: &mut gpui::TestAppContext) {
1469        cx.update(|cx| {
1470            let settings = SettingsStore::test(cx);
1471            cx.set_global(settings);
1472            theme::init(LoadThemes::JustBase, cx);
1473        });
1474    }
1475
1476    fn wrap_text(
1477        tab_snapshot: &TabSnapshot,
1478        wrap_width: Option<Pixels>,
1479        line_wrapper: &mut LineWrapper,
1480    ) -> String {
1481        if let Some(wrap_width) = wrap_width {
1482            let mut wrapped_text = String::new();
1483            for (row, line) in tab_snapshot.text().split('\n').enumerate() {
1484                if row > 0 {
1485                    wrapped_text.push('\n');
1486                }
1487
1488                let mut prev_ix = 0;
1489                for boundary in line_wrapper.wrap_line(&[LineFragment::text(line)], wrap_width) {
1490                    wrapped_text.push_str(&line[prev_ix..boundary.ix]);
1491                    wrapped_text.push('\n');
1492                    wrapped_text.push_str(&" ".repeat(boundary.next_indent as usize));
1493                    prev_ix = boundary.ix;
1494                }
1495                wrapped_text.push_str(&line[prev_ix..]);
1496            }
1497
1498            wrapped_text
1499        } else {
1500            tab_snapshot.text()
1501        }
1502    }
1503
1504    impl WrapSnapshot {
1505        fn verify_chunks(&mut self, rng: &mut impl Rng) {
1506            for _ in 0..5 {
1507                let mut end_row = rng.random_range(0..=self.max_point().row().0);
1508                let start_row = rng.random_range(0..=end_row);
1509                end_row += 1;
1510
1511                let mut expected_text = self.text_chunks(WrapRow(start_row)).collect::<String>();
1512                if expected_text.ends_with('\n') {
1513                    expected_text.push('\n');
1514                }
1515                let mut expected_text = expected_text
1516                    .lines()
1517                    .take((end_row - start_row) as usize)
1518                    .collect::<Vec<_>>()
1519                    .join("\n");
1520                if end_row <= self.max_point().row().0 {
1521                    expected_text.push('\n');
1522                }
1523
1524                let actual_text = self
1525                    .chunks(
1526                        WrapRow(start_row)..WrapRow(end_row),
1527                        true,
1528                        Highlights::default(),
1529                    )
1530                    .map(|c| c.text)
1531                    .collect::<String>();
1532                assert_eq!(
1533                    expected_text,
1534                    actual_text,
1535                    "chunks != highlighted_chunks for rows {:?}",
1536                    start_row..end_row
1537                );
1538            }
1539        }
1540    }
1541}