1use super::wrap_map::{self, WrapEdit, WrapPoint, WrapSnapshot};
2use crate::{Anchor, ToOffset, ToPoint as _};
3use gpui::{AppContext, ElementBox};
4use language::Chunk;
5use parking_lot::Mutex;
6use std::{
7 cmp::{self, Ordering},
8 collections::{HashMap, HashSet},
9 fmt::Debug,
10 ops::{Deref, Range},
11 sync::{
12 atomic::{AtomicUsize, Ordering::SeqCst},
13 Arc,
14 },
15};
16use sum_tree::{Bias, SumTree};
17use text::{Edit, Point};
18use theme::SyntaxTheme;
19
20const NEWLINES: &'static [u8] = &[b'\n'; u8::MAX as usize];
21
22pub struct BlockMap {
23 next_block_id: AtomicUsize,
24 wrap_snapshot: Mutex<WrapSnapshot>,
25 blocks: Vec<Arc<Block>>,
26 transforms: Mutex<SumTree<Transform>>,
27}
28
29pub struct BlockMapWriter<'a>(&'a mut BlockMap);
30
31pub struct BlockSnapshot {
32 wrap_snapshot: WrapSnapshot,
33 transforms: SumTree<Transform>,
34}
35
36#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
37pub struct BlockId(usize);
38
39#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
40pub struct BlockPoint(pub super::Point);
41
42#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
43struct BlockRow(u32);
44
45#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
46struct WrapRow(u32);
47
48pub type RenderBlock = Arc<dyn Fn(&BlockContext) -> ElementBox>;
49
50pub struct Block {
51 id: BlockId,
52 position: Anchor,
53 height: u8,
54 render: Mutex<RenderBlock>,
55 disposition: BlockDisposition,
56}
57
58#[derive(Clone)]
59pub struct BlockProperties<P>
60where
61 P: Clone,
62{
63 pub position: P,
64 pub height: u8,
65 pub render: Arc<dyn Fn(&BlockContext) -> ElementBox>,
66 pub disposition: BlockDisposition,
67}
68
69pub struct BlockContext<'a> {
70 pub cx: &'a AppContext,
71 pub anchor_x: f32,
72}
73
74#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
75pub enum BlockDisposition {
76 Above,
77 Below,
78}
79
80#[derive(Clone, Debug)]
81struct Transform {
82 summary: TransformSummary,
83 block: Option<AlignedBlock>,
84}
85
86#[derive(Clone, Debug)]
87pub struct AlignedBlock {
88 block: Arc<Block>,
89 column: u32,
90}
91
92#[derive(Clone, Debug, Default)]
93struct TransformSummary {
94 input_rows: u32,
95 output_rows: u32,
96}
97
98pub struct BlockChunks<'a> {
99 transforms: sum_tree::Cursor<'a, Transform, (BlockRow, WrapRow)>,
100 input_chunks: wrap_map::WrapChunks<'a>,
101 input_chunk: Chunk<'a>,
102 output_row: u32,
103 max_output_row: u32,
104}
105
106pub struct BlockBufferRows<'a> {
107 transforms: sum_tree::Cursor<'a, Transform, (BlockRow, WrapRow)>,
108 input_buffer_rows: wrap_map::WrapBufferRows<'a>,
109 output_row: u32,
110 started: bool,
111}
112
113impl BlockMap {
114 pub fn new(wrap_snapshot: WrapSnapshot) -> Self {
115 Self {
116 next_block_id: AtomicUsize::new(0),
117 blocks: Vec::new(),
118 transforms: Mutex::new(SumTree::from_item(
119 Transform::isomorphic(wrap_snapshot.text_summary().lines.row + 1),
120 &(),
121 )),
122 wrap_snapshot: Mutex::new(wrap_snapshot),
123 }
124 }
125
126 pub fn read(&self, wrap_snapshot: WrapSnapshot, edits: Vec<WrapEdit>) -> BlockSnapshot {
127 self.sync(&wrap_snapshot, edits);
128 *self.wrap_snapshot.lock() = wrap_snapshot.clone();
129 BlockSnapshot {
130 wrap_snapshot,
131 transforms: self.transforms.lock().clone(),
132 }
133 }
134
135 pub fn write(&mut self, wrap_snapshot: WrapSnapshot, edits: Vec<WrapEdit>) -> BlockMapWriter {
136 self.sync(&wrap_snapshot, edits);
137 *self.wrap_snapshot.lock() = wrap_snapshot;
138 BlockMapWriter(self)
139 }
140
141 fn sync(&self, wrap_snapshot: &WrapSnapshot, edits: Vec<WrapEdit>) {
142 if edits.is_empty() {
143 return;
144 }
145
146 let buffer = wrap_snapshot.buffer_snapshot();
147 let mut transforms = self.transforms.lock();
148 let mut new_transforms = SumTree::new();
149 let old_row_count = transforms.summary().input_rows;
150 let new_row_count = wrap_snapshot.max_point().row() + 1;
151 let mut cursor = transforms.cursor::<WrapRow>();
152 let mut last_block_ix = 0;
153 let mut blocks_in_edit = Vec::new();
154 let mut edits = edits.into_iter().peekable();
155
156 while let Some(edit) = edits.next() {
157 // Preserve any old transforms that precede this edit.
158 let old_start = WrapRow(edit.old.start);
159 let new_start = WrapRow(edit.new.start);
160 new_transforms.push_tree(cursor.slice(&old_start, Bias::Left, &()), &());
161 if let Some(transform) = cursor.item() {
162 if transform.is_isomorphic() && old_start == cursor.end(&()) {
163 new_transforms.push(transform.clone(), &());
164 cursor.next(&());
165 while let Some(transform) = cursor.item() {
166 if transform
167 .block
168 .as_ref()
169 .map_or(false, |b| b.disposition.is_below())
170 {
171 new_transforms.push(transform.clone(), &());
172 cursor.next(&());
173 } else {
174 break;
175 }
176 }
177 }
178 }
179
180 // Preserve any portion of an old transform that precedes this edit.
181 let extent_before_edit = old_start.0 - cursor.start().0;
182 push_isomorphic(&mut new_transforms, extent_before_edit);
183
184 // Skip over any old transforms that intersect this edit.
185 let mut old_end = WrapRow(edit.old.end);
186 let mut new_end = WrapRow(edit.new.end);
187 cursor.seek(&old_end, Bias::Left, &());
188 cursor.next(&());
189 if old_end == *cursor.start() {
190 while let Some(transform) = cursor.item() {
191 if transform
192 .block
193 .as_ref()
194 .map_or(false, |b| b.disposition.is_below())
195 {
196 cursor.next(&());
197 } else {
198 break;
199 }
200 }
201 }
202
203 // Combine this edit with any subsequent edits that intersect the same transform.
204 while let Some(next_edit) = edits.peek() {
205 if next_edit.old.start <= cursor.start().0 {
206 old_end = WrapRow(next_edit.old.end);
207 new_end = WrapRow(next_edit.new.end);
208 cursor.seek(&old_end, Bias::Left, &());
209 cursor.next(&());
210 if old_end == *cursor.start() {
211 while let Some(transform) = cursor.item() {
212 if transform
213 .block
214 .as_ref()
215 .map_or(false, |b| b.disposition.is_below())
216 {
217 cursor.next(&());
218 } else {
219 break;
220 }
221 }
222 }
223 edits.next();
224 } else {
225 break;
226 }
227 }
228
229 // Find the blocks within this edited region.
230 let new_start = wrap_snapshot.to_point(WrapPoint::new(new_start.0, 0), Bias::Left);
231 let start_anchor = buffer.anchor_before(new_start);
232 let start_block_ix = match self.blocks[last_block_ix..].binary_search_by(|probe| {
233 probe
234 .position
235 .cmp(&start_anchor, &buffer)
236 .unwrap()
237 .then(Ordering::Greater)
238 }) {
239 Ok(ix) | Err(ix) => last_block_ix + ix,
240 };
241 let end_block_ix = if new_end.0 > wrap_snapshot.max_point().row() {
242 self.blocks.len()
243 } else {
244 let new_end = wrap_snapshot.to_point(WrapPoint::new(new_end.0, 0), Bias::Left);
245 let end_anchor = buffer.anchor_before(new_end);
246 match self.blocks[start_block_ix..].binary_search_by(|probe| {
247 probe
248 .position
249 .cmp(&end_anchor, &buffer)
250 .unwrap()
251 .then(Ordering::Greater)
252 }) {
253 Ok(ix) | Err(ix) => start_block_ix + ix,
254 }
255 };
256 last_block_ix = end_block_ix;
257 blocks_in_edit.clear();
258 blocks_in_edit.extend(
259 self.blocks[start_block_ix..end_block_ix]
260 .iter()
261 .map(|block| {
262 let mut position = block.position.to_point(&buffer);
263 let column = wrap_snapshot.from_point(position, Bias::Left).column();
264 match block.disposition {
265 BlockDisposition::Above => position.column = 0,
266 BlockDisposition::Below => {
267 position.column = buffer.line_len(position.row)
268 }
269 }
270 let position = wrap_snapshot.from_point(position, Bias::Left);
271 (position.row(), column, block)
272 }),
273 );
274 blocks_in_edit
275 .sort_unstable_by_key(|(row, _, block)| (*row, block.disposition, block.id));
276
277 // For each of these blocks, insert a new isomorphic transform preceding the block,
278 // and then insert the block itself.
279 for (block_row, column, block) in blocks_in_edit.iter().copied() {
280 let insertion_row = match block.disposition {
281 BlockDisposition::Above => block_row,
282 BlockDisposition::Below => block_row + 1,
283 };
284 let extent_before_block = insertion_row - new_transforms.summary().input_rows;
285 push_isomorphic(&mut new_transforms, extent_before_block);
286 new_transforms.push(Transform::block(block.clone(), column), &());
287 }
288
289 old_end = WrapRow(old_end.0.min(old_row_count));
290 new_end = WrapRow(new_end.0.min(new_row_count));
291
292 // Insert an isomorphic transform after the final block.
293 let extent_after_last_block = new_end.0 - new_transforms.summary().input_rows;
294 push_isomorphic(&mut new_transforms, extent_after_last_block);
295
296 // Preserve any portion of the old transform after this edit.
297 let extent_after_edit = cursor.start().0 - old_end.0;
298 push_isomorphic(&mut new_transforms, extent_after_edit);
299 }
300
301 new_transforms.push_tree(cursor.suffix(&()), &());
302 debug_assert_eq!(
303 new_transforms.summary().input_rows,
304 wrap_snapshot.max_point().row() + 1
305 );
306
307 drop(cursor);
308 *transforms = new_transforms;
309 }
310
311 pub fn replace(&mut self, mut renderers: HashMap<BlockId, RenderBlock>) {
312 for block in &self.blocks {
313 if let Some(render) = renderers.remove(&block.id) {
314 *block.render.lock() = render;
315 }
316 }
317 }
318}
319
320fn push_isomorphic(tree: &mut SumTree<Transform>, rows: u32) {
321 if rows == 0 {
322 return;
323 }
324
325 let mut extent = Some(rows);
326 tree.update_last(
327 |last_transform| {
328 if last_transform.is_isomorphic() {
329 let extent = extent.take().unwrap();
330 last_transform.summary.input_rows += extent;
331 last_transform.summary.output_rows += extent;
332 }
333 },
334 &(),
335 );
336 if let Some(extent) = extent {
337 tree.push(Transform::isomorphic(extent), &());
338 }
339}
340
341impl BlockPoint {
342 pub fn new(row: u32, column: u32) -> Self {
343 Self(Point::new(row, column))
344 }
345}
346
347impl Deref for BlockPoint {
348 type Target = Point;
349
350 fn deref(&self) -> &Self::Target {
351 &self.0
352 }
353}
354
355impl std::ops::DerefMut for BlockPoint {
356 fn deref_mut(&mut self) -> &mut Self::Target {
357 &mut self.0
358 }
359}
360
361impl<'a> BlockMapWriter<'a> {
362 pub fn insert<P>(
363 &mut self,
364 blocks: impl IntoIterator<Item = BlockProperties<P>>,
365 ) -> Vec<BlockId>
366 where
367 P: ToOffset + Clone,
368 {
369 let mut ids = Vec::new();
370 let mut edits = Vec::<Edit<u32>>::new();
371 let wrap_snapshot = &*self.0.wrap_snapshot.lock();
372 let buffer = wrap_snapshot.buffer_snapshot();
373
374 for block in blocks {
375 let id = BlockId(self.0.next_block_id.fetch_add(1, SeqCst));
376 ids.push(id);
377
378 let position = buffer.anchor_after(block.position);
379 let point = position.to_point(&buffer);
380 let wrap_row = wrap_snapshot
381 .from_point(Point::new(point.row, 0), Bias::Left)
382 .row();
383 let start_row = wrap_snapshot.prev_row_boundary(WrapPoint::new(wrap_row, 0));
384 let end_row = wrap_snapshot
385 .next_row_boundary(WrapPoint::new(wrap_row, 0))
386 .unwrap_or(wrap_snapshot.max_point().row() + 1);
387
388 let block_ix = match self
389 .0
390 .blocks
391 .binary_search_by(|probe| probe.position.cmp(&position, &buffer).unwrap())
392 {
393 Ok(ix) | Err(ix) => ix,
394 };
395 self.0.blocks.insert(
396 block_ix,
397 Arc::new(Block {
398 id,
399 position,
400 height: block.height,
401 render: Mutex::new(block.render),
402 disposition: block.disposition,
403 }),
404 );
405
406 if let Err(edit_ix) = edits.binary_search_by_key(&start_row, |edit| edit.old.start) {
407 edits.insert(
408 edit_ix,
409 Edit {
410 old: start_row..end_row,
411 new: start_row..end_row,
412 },
413 );
414 }
415 }
416
417 self.0.sync(wrap_snapshot, edits);
418 ids
419 }
420
421 pub fn remove(&mut self, block_ids: HashSet<BlockId>) {
422 let wrap_snapshot = &*self.0.wrap_snapshot.lock();
423 let buffer = wrap_snapshot.buffer_snapshot();
424 let mut edits = Vec::new();
425 let mut last_block_buffer_row = None;
426 self.0.blocks.retain(|block| {
427 if block_ids.contains(&block.id) {
428 let buffer_row = block.position.to_point(&buffer).row;
429 if last_block_buffer_row != Some(buffer_row) {
430 last_block_buffer_row = Some(buffer_row);
431 let wrap_row = wrap_snapshot
432 .from_point(Point::new(buffer_row, 0), Bias::Left)
433 .row();
434 let start_row = wrap_snapshot.prev_row_boundary(WrapPoint::new(wrap_row, 0));
435 let end_row = wrap_snapshot
436 .next_row_boundary(WrapPoint::new(wrap_row, 0))
437 .unwrap_or(wrap_snapshot.max_point().row() + 1);
438 edits.push(Edit {
439 old: start_row..end_row,
440 new: start_row..end_row,
441 })
442 }
443 false
444 } else {
445 true
446 }
447 });
448 self.0.sync(wrap_snapshot, edits);
449 }
450}
451
452impl BlockSnapshot {
453 #[cfg(test)]
454 pub fn text(&self) -> String {
455 self.chunks(0..self.transforms.summary().output_rows, None)
456 .map(|chunk| chunk.text)
457 .collect()
458 }
459
460 pub fn chunks<'a>(
461 &'a self,
462 rows: Range<u32>,
463 theme: Option<&'a SyntaxTheme>,
464 ) -> BlockChunks<'a> {
465 let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows);
466 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
467 let input_end = {
468 cursor.seek(&BlockRow(rows.end), Bias::Right, &());
469 let overshoot = if cursor
470 .item()
471 .map_or(false, |transform| transform.is_isomorphic())
472 {
473 rows.end - cursor.start().0 .0
474 } else {
475 0
476 };
477 cursor.start().1 .0 + overshoot
478 };
479 let input_start = {
480 cursor.seek(&BlockRow(rows.start), Bias::Right, &());
481 let overshoot = if cursor
482 .item()
483 .map_or(false, |transform| transform.is_isomorphic())
484 {
485 rows.start - cursor.start().0 .0
486 } else {
487 0
488 };
489 cursor.start().1 .0 + overshoot
490 };
491 BlockChunks {
492 input_chunks: self.wrap_snapshot.chunks(input_start..input_end, theme),
493 input_chunk: Default::default(),
494 transforms: cursor,
495 output_row: rows.start,
496 max_output_row,
497 }
498 }
499
500 pub fn buffer_rows<'a>(&'a self, start_row: u32) -> BlockBufferRows<'a> {
501 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
502 cursor.seek(&BlockRow(start_row), Bias::Right, &());
503 let (output_start, input_start) = cursor.start();
504 let overshoot = if cursor.item().map_or(false, |t| t.is_isomorphic()) {
505 start_row - output_start.0
506 } else {
507 0
508 };
509 let input_start_row = input_start.0 + overshoot;
510 BlockBufferRows {
511 transforms: cursor,
512 input_buffer_rows: self.wrap_snapshot.buffer_rows(input_start_row),
513 output_row: start_row,
514 started: false,
515 }
516 }
517
518 pub fn blocks_in_range<'a>(
519 &'a self,
520 rows: Range<u32>,
521 ) -> impl Iterator<Item = (u32, &'a AlignedBlock)> {
522 let mut cursor = self.transforms.cursor::<BlockRow>();
523 cursor.seek(&BlockRow(rows.start), Bias::Right, &());
524 std::iter::from_fn(move || {
525 while let Some(transform) = cursor.item() {
526 let start_row = cursor.start().0;
527 if start_row >= rows.end {
528 break;
529 }
530 if let Some(block) = &transform.block {
531 cursor.next(&());
532 return Some((start_row, block));
533 } else {
534 cursor.next(&());
535 }
536 }
537 None
538 })
539 }
540
541 pub fn max_point(&self) -> BlockPoint {
542 let row = self.transforms.summary().output_rows - 1;
543 BlockPoint::new(row, self.line_len(row))
544 }
545
546 pub fn longest_row(&self) -> u32 {
547 let input_row = self.wrap_snapshot.longest_row();
548 self.to_block_point(WrapPoint::new(input_row, 0)).row
549 }
550
551 pub fn line_len(&self, row: u32) -> u32 {
552 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
553 cursor.seek(&BlockRow(row), Bias::Right, &());
554 if let Some(transform) = cursor.item() {
555 let (output_start, input_start) = cursor.start();
556 let overshoot = row - output_start.0;
557 if transform.block.is_some() {
558 0
559 } else {
560 self.wrap_snapshot.line_len(input_start.0 + overshoot)
561 }
562 } else {
563 panic!("row out of range");
564 }
565 }
566
567 pub fn is_block_line(&self, row: u32) -> bool {
568 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
569 cursor.seek(&BlockRow(row), Bias::Right, &());
570 cursor.item().map_or(false, |t| t.block.is_some())
571 }
572
573 pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
574 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
575 cursor.seek(&BlockRow(point.row), Bias::Right, &());
576
577 let max_input_row = WrapRow(self.transforms.summary().input_rows);
578 let mut search_left =
579 (bias == Bias::Left && cursor.start().1 .0 > 0) || cursor.end(&()).1 == max_input_row;
580 let mut reversed = false;
581
582 loop {
583 if let Some(transform) = cursor.item() {
584 if transform.is_isomorphic() {
585 let (output_start_row, input_start_row) = cursor.start();
586 let (output_end_row, input_end_row) = cursor.end(&());
587 let output_start = Point::new(output_start_row.0, 0);
588 let input_start = Point::new(input_start_row.0, 0);
589 let input_end = Point::new(input_end_row.0, 0);
590 let input_point = if point.row >= output_end_row.0 {
591 let line_len = self.wrap_snapshot.line_len(input_end_row.0 - 1);
592 self.wrap_snapshot
593 .clip_point(WrapPoint::new(input_end_row.0 - 1, line_len), bias)
594 } else {
595 let output_overshoot = point.0.saturating_sub(output_start);
596 self.wrap_snapshot
597 .clip_point(WrapPoint(input_start + output_overshoot), bias)
598 };
599
600 if (input_start..input_end).contains(&input_point.0) {
601 let input_overshoot = input_point.0.saturating_sub(input_start);
602 return BlockPoint(output_start + input_overshoot);
603 }
604 }
605
606 if search_left {
607 cursor.prev(&());
608 } else {
609 cursor.next(&());
610 }
611 } else if reversed {
612 return self.max_point();
613 } else {
614 reversed = true;
615 search_left = !search_left;
616 cursor.seek(&BlockRow(point.row), Bias::Right, &());
617 }
618 }
619 }
620
621 pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint {
622 let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>();
623 cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &());
624 if let Some(transform) = cursor.item() {
625 debug_assert!(transform.is_isomorphic());
626 } else {
627 return self.max_point();
628 }
629
630 let (input_start_row, output_start_row) = cursor.start();
631 let input_start = Point::new(input_start_row.0, 0);
632 let output_start = Point::new(output_start_row.0, 0);
633 let input_overshoot = wrap_point.0 - input_start;
634 BlockPoint(output_start + input_overshoot)
635 }
636
637 pub fn to_wrap_point(&self, block_point: BlockPoint) -> WrapPoint {
638 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
639 cursor.seek(&BlockRow(block_point.row), Bias::Right, &());
640 if let Some(transform) = cursor.item() {
641 match transform.block.as_ref().map(|b| b.disposition) {
642 Some(BlockDisposition::Above) => WrapPoint::new(cursor.start().1 .0, 0),
643 Some(BlockDisposition::Below) => {
644 let wrap_row = cursor.start().1 .0 - 1;
645 WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
646 }
647 None => {
648 let overshoot = block_point.row - cursor.start().0 .0;
649 let wrap_row = cursor.start().1 .0 + overshoot;
650 WrapPoint::new(wrap_row, block_point.column)
651 }
652 }
653 } else {
654 self.wrap_snapshot.max_point()
655 }
656 }
657}
658
659impl Transform {
660 fn isomorphic(rows: u32) -> Self {
661 Self {
662 summary: TransformSummary {
663 input_rows: rows,
664 output_rows: rows,
665 },
666 block: None,
667 }
668 }
669
670 fn block(block: Arc<Block>, column: u32) -> Self {
671 Self {
672 summary: TransformSummary {
673 input_rows: 0,
674 output_rows: block.height as u32,
675 },
676 block: Some(AlignedBlock { block, column }),
677 }
678 }
679
680 fn is_isomorphic(&self) -> bool {
681 self.block.is_none()
682 }
683}
684
685impl<'a> Iterator for BlockChunks<'a> {
686 type Item = Chunk<'a>;
687
688 fn next(&mut self) -> Option<Self::Item> {
689 if self.output_row >= self.max_output_row {
690 return None;
691 }
692
693 let transform = self.transforms.item()?;
694 if transform.block.is_some() {
695 let block_start = self.transforms.start().0 .0;
696 let mut block_end = self.transforms.end(&()).0 .0;
697 self.transforms.next(&());
698 if self.transforms.item().is_none() {
699 block_end -= 1;
700 }
701
702 let start_in_block = self.output_row - block_start;
703 let end_in_block = cmp::min(self.max_output_row, block_end) - block_start;
704 let line_count = end_in_block - start_in_block;
705 self.output_row += line_count;
706
707 return Some(Chunk {
708 text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..line_count as usize]) },
709 highlight_style: None,
710 diagnostic: None,
711 });
712 }
713
714 if self.input_chunk.text.is_empty() {
715 if let Some(input_chunk) = self.input_chunks.next() {
716 self.input_chunk = input_chunk;
717 } else {
718 self.output_row += 1;
719 if self.output_row < self.max_output_row {
720 self.transforms.next(&());
721 return Some(Chunk {
722 text: "\n",
723 ..Default::default()
724 });
725 } else {
726 return None;
727 }
728 }
729 }
730
731 let transform_end = self.transforms.end(&()).0 .0;
732 let (prefix_rows, prefix_bytes) =
733 offset_for_row(self.input_chunk.text, transform_end - self.output_row);
734 self.output_row += prefix_rows;
735 let (prefix, suffix) = self.input_chunk.text.split_at(prefix_bytes);
736 self.input_chunk.text = suffix;
737 if self.output_row == transform_end {
738 self.transforms.next(&());
739 }
740
741 Some(Chunk {
742 text: prefix,
743 ..self.input_chunk
744 })
745 }
746}
747
748impl<'a> Iterator for BlockBufferRows<'a> {
749 type Item = Option<u32>;
750
751 fn next(&mut self) -> Option<Self::Item> {
752 if self.started {
753 self.output_row += 1;
754 } else {
755 self.started = true;
756 }
757
758 if self.output_row >= self.transforms.end(&()).0 .0 {
759 self.transforms.next(&());
760 }
761
762 let transform = self.transforms.item()?;
763 if transform.block.is_some() {
764 Some(None)
765 } else {
766 Some(self.input_buffer_rows.next().unwrap())
767 }
768 }
769}
770
771impl sum_tree::Item for Transform {
772 type Summary = TransformSummary;
773
774 fn summary(&self) -> Self::Summary {
775 self.summary.clone()
776 }
777}
778
779impl sum_tree::Summary for TransformSummary {
780 type Context = ();
781
782 fn add_summary(&mut self, summary: &Self, _: &()) {
783 self.input_rows += summary.input_rows;
784 self.output_rows += summary.output_rows;
785 }
786}
787
788impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapRow {
789 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
790 self.0 += summary.input_rows;
791 }
792}
793
794impl<'a> sum_tree::Dimension<'a, TransformSummary> for BlockRow {
795 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
796 self.0 += summary.output_rows;
797 }
798}
799
800impl BlockDisposition {
801 fn is_below(&self) -> bool {
802 matches!(self, BlockDisposition::Below)
803 }
804}
805
806impl AlignedBlock {
807 pub fn height(&self) -> u32 {
808 self.height as u32
809 }
810
811 pub fn column(&self) -> u32 {
812 self.column
813 }
814
815 pub fn render(&self, cx: &BlockContext) -> ElementBox {
816 self.render.lock()(cx)
817 }
818
819 pub fn position(&self) -> &Anchor {
820 &self.block.position
821 }
822}
823
824impl Deref for AlignedBlock {
825 type Target = Block;
826
827 fn deref(&self) -> &Self::Target {
828 self.block.as_ref()
829 }
830}
831
832impl<'a> Deref for BlockContext<'a> {
833 type Target = AppContext;
834
835 fn deref(&self) -> &Self::Target {
836 &self.cx
837 }
838}
839
840impl Debug for Block {
841 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
842 f.debug_struct("Block")
843 .field("id", &self.id)
844 .field("position", &self.position)
845 .field("disposition", &self.disposition)
846 .finish()
847 }
848}
849
850// Count the number of bytes prior to a target point. If the string doesn't contain the target
851// point, return its total extent. Otherwise return the target point itself.
852fn offset_for_row(s: &str, target: u32) -> (u32, usize) {
853 let mut row = 0;
854 let mut offset = 0;
855 for (ix, line) in s.split('\n').enumerate() {
856 if ix > 0 {
857 row += 1;
858 offset += 1;
859 }
860 if row >= target {
861 break;
862 }
863 offset += line.len() as usize;
864 }
865 (row, offset)
866}
867
868#[cfg(test)]
869mod tests {
870 use super::*;
871 use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap};
872 use crate::multi_buffer::MultiBuffer;
873 use gpui::{elements::Empty, Element};
874 use rand::prelude::*;
875 use std::env;
876 use text::RandomCharIter;
877
878 #[gpui::test]
879 fn test_offset_for_row() {
880 assert_eq!(offset_for_row("", 0), (0, 0));
881 assert_eq!(offset_for_row("", 1), (0, 0));
882 assert_eq!(offset_for_row("abcd", 0), (0, 0));
883 assert_eq!(offset_for_row("abcd", 1), (0, 4));
884 assert_eq!(offset_for_row("\n", 0), (0, 0));
885 assert_eq!(offset_for_row("\n", 1), (1, 1));
886 assert_eq!(offset_for_row("abc\ndef\nghi", 0), (0, 0));
887 assert_eq!(offset_for_row("abc\ndef\nghi", 1), (1, 4));
888 assert_eq!(offset_for_row("abc\ndef\nghi", 2), (2, 8));
889 assert_eq!(offset_for_row("abc\ndef\nghi", 3), (2, 11));
890 }
891
892 #[gpui::test]
893 fn test_basic_blocks(cx: &mut gpui::MutableAppContext) {
894 let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
895 let font_id = cx
896 .font_cache()
897 .select_font(family_id, &Default::default())
898 .unwrap();
899
900 let text = "aaa\nbbb\nccc\nddd";
901
902 let buffer = MultiBuffer::build_simple(text, cx);
903 let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
904 let (fold_map, folds_snapshot) = FoldMap::new(buffer.read(cx).snapshot(cx));
905 let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), 1);
906 let (wrap_map, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, None, cx);
907 let mut block_map = BlockMap::new(wraps_snapshot.clone());
908
909 let mut writer = block_map.write(wraps_snapshot.clone(), vec![]);
910 writer.insert(vec![
911 BlockProperties {
912 position: Point::new(1, 0),
913 height: 1,
914 disposition: BlockDisposition::Above,
915 render: Arc::new(|_| Empty::new().named("block 1")),
916 },
917 BlockProperties {
918 position: Point::new(1, 2),
919 height: 2,
920 disposition: BlockDisposition::Above,
921 render: Arc::new(|_| Empty::new().named("block 2")),
922 },
923 BlockProperties {
924 position: Point::new(3, 3),
925 height: 3,
926 disposition: BlockDisposition::Below,
927 render: Arc::new(|_| Empty::new().named("block 3")),
928 },
929 ]);
930
931 let snapshot = block_map.read(wraps_snapshot, vec![]);
932 assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
933
934 let blocks = snapshot
935 .blocks_in_range(0..8)
936 .map(|(start_row, block)| {
937 (
938 start_row..start_row + block.height(),
939 block.column(),
940 block
941 .render(&BlockContext { cx, anchor_x: 0. })
942 .name()
943 .unwrap()
944 .to_string(),
945 )
946 })
947 .collect::<Vec<_>>();
948 assert_eq!(
949 blocks,
950 &[
951 (1..2, 0, "block 1".to_string()),
952 (2..4, 2, "block 2".to_string()),
953 (7..10, 3, "block 3".to_string()),
954 ]
955 );
956
957 assert_eq!(
958 snapshot.to_block_point(WrapPoint::new(0, 3)),
959 BlockPoint::new(0, 3)
960 );
961 assert_eq!(
962 snapshot.to_block_point(WrapPoint::new(1, 0)),
963 BlockPoint::new(4, 0)
964 );
965 assert_eq!(
966 snapshot.to_block_point(WrapPoint::new(3, 3)),
967 BlockPoint::new(6, 3)
968 );
969
970 assert_eq!(
971 snapshot.to_wrap_point(BlockPoint::new(0, 3)),
972 WrapPoint::new(0, 3)
973 );
974 assert_eq!(
975 snapshot.to_wrap_point(BlockPoint::new(1, 0)),
976 WrapPoint::new(1, 0)
977 );
978 assert_eq!(
979 snapshot.to_wrap_point(BlockPoint::new(3, 0)),
980 WrapPoint::new(1, 0)
981 );
982 assert_eq!(
983 snapshot.to_wrap_point(BlockPoint::new(7, 0)),
984 WrapPoint::new(3, 3)
985 );
986
987 assert_eq!(
988 snapshot.clip_point(BlockPoint::new(1, 0), Bias::Left),
989 BlockPoint::new(0, 3)
990 );
991 assert_eq!(
992 snapshot.clip_point(BlockPoint::new(1, 0), Bias::Right),
993 BlockPoint::new(4, 0)
994 );
995 assert_eq!(
996 snapshot.clip_point(BlockPoint::new(1, 1), Bias::Left),
997 BlockPoint::new(0, 3)
998 );
999 assert_eq!(
1000 snapshot.clip_point(BlockPoint::new(1, 1), Bias::Right),
1001 BlockPoint::new(4, 0)
1002 );
1003 assert_eq!(
1004 snapshot.clip_point(BlockPoint::new(4, 0), Bias::Left),
1005 BlockPoint::new(4, 0)
1006 );
1007 assert_eq!(
1008 snapshot.clip_point(BlockPoint::new(4, 0), Bias::Right),
1009 BlockPoint::new(4, 0)
1010 );
1011 assert_eq!(
1012 snapshot.clip_point(BlockPoint::new(6, 3), Bias::Left),
1013 BlockPoint::new(6, 3)
1014 );
1015 assert_eq!(
1016 snapshot.clip_point(BlockPoint::new(6, 3), Bias::Right),
1017 BlockPoint::new(6, 3)
1018 );
1019 assert_eq!(
1020 snapshot.clip_point(BlockPoint::new(7, 0), Bias::Left),
1021 BlockPoint::new(6, 3)
1022 );
1023 assert_eq!(
1024 snapshot.clip_point(BlockPoint::new(7, 0), Bias::Right),
1025 BlockPoint::new(6, 3)
1026 );
1027
1028 assert_eq!(
1029 snapshot.buffer_rows(0).collect::<Vec<_>>(),
1030 &[
1031 Some(0),
1032 None,
1033 None,
1034 None,
1035 Some(1),
1036 Some(2),
1037 Some(3),
1038 None,
1039 None,
1040 None
1041 ]
1042 );
1043
1044 // Insert a line break, separating two block decorations into separate lines.
1045 let buffer_snapshot = buffer.update(cx, |buffer, cx| {
1046 buffer.edit([Point::new(1, 1)..Point::new(1, 1)], "!!!\n", cx);
1047 buffer.snapshot(cx)
1048 });
1049
1050 let (folds_snapshot, fold_edits) =
1051 fold_map.read(buffer_snapshot, subscription.consume().into_inner());
1052 let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1053 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1054 wrap_map.sync(tabs_snapshot, tab_edits, cx)
1055 });
1056 let snapshot = block_map.read(wraps_snapshot, wrap_edits);
1057 assert_eq!(snapshot.text(), "aaa\n\nb!!!\n\n\nbb\nccc\nddd\n\n\n");
1058 }
1059
1060 #[gpui::test]
1061 fn test_blocks_on_wrapped_lines(cx: &mut gpui::MutableAppContext) {
1062 let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
1063 let font_id = cx
1064 .font_cache()
1065 .select_font(family_id, &Default::default())
1066 .unwrap();
1067
1068 let text = "one two three\nfour five six\nseven eight";
1069
1070 let buffer = MultiBuffer::build_simple(text, cx);
1071 let (_, folds_snapshot) = FoldMap::new(buffer.read(cx).snapshot(cx));
1072 let (_, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), 1);
1073 let (_, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, Some(60.), cx);
1074 let mut block_map = BlockMap::new(wraps_snapshot.clone());
1075
1076 let mut writer = block_map.write(wraps_snapshot.clone(), vec![]);
1077 writer.insert(vec![
1078 BlockProperties {
1079 position: Point::new(1, 12),
1080 disposition: BlockDisposition::Above,
1081 render: Arc::new(|_| Empty::new().named("block 1")),
1082 height: 1,
1083 },
1084 BlockProperties {
1085 position: Point::new(1, 1),
1086 disposition: BlockDisposition::Below,
1087 render: Arc::new(|_| Empty::new().named("block 2")),
1088 height: 1,
1089 },
1090 ]);
1091
1092 // Blocks with an 'above' disposition go above their corresponding buffer line.
1093 // Blocks with a 'below' disposition go below their corresponding buffer line.
1094 let snapshot = block_map.read(wraps_snapshot, vec![]);
1095 assert_eq!(
1096 snapshot.text(),
1097 "one two \nthree\n\nfour five \nsix\n\nseven \neight"
1098 );
1099 }
1100
1101 #[gpui::test(iterations = 100)]
1102 fn test_random_blocks(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
1103 let operations = env::var("OPERATIONS")
1104 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1105 .unwrap_or(10);
1106
1107 let wrap_width = if rng.gen_bool(0.2) {
1108 None
1109 } else {
1110 Some(rng.gen_range(0.0..=100.0))
1111 };
1112 let tab_size = 1;
1113 let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
1114 let font_id = cx
1115 .font_cache()
1116 .select_font(family_id, &Default::default())
1117 .unwrap();
1118 let font_size = 14.0;
1119
1120 log::info!("Wrap width: {:?}", wrap_width);
1121
1122 let buffer = if rng.gen() {
1123 let len = rng.gen_range(0..10);
1124 let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
1125 log::info!("initial buffer text: {:?}", text);
1126 MultiBuffer::build_simple(&text, cx)
1127 } else {
1128 MultiBuffer::build_random(&mut rng, cx)
1129 };
1130
1131 let mut buffer_snapshot = buffer.read(cx).snapshot(cx);
1132 let (fold_map, folds_snapshot) = FoldMap::new(buffer_snapshot.clone());
1133 let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
1134 let (wrap_map, wraps_snapshot) =
1135 WrapMap::new(tabs_snapshot, font_id, font_size, wrap_width, cx);
1136 let mut block_map = BlockMap::new(wraps_snapshot);
1137 let mut expected_blocks = Vec::new();
1138
1139 for _ in 0..operations {
1140 let mut buffer_edits = Vec::new();
1141 match rng.gen_range(0..=100) {
1142 0..=19 => {
1143 let wrap_width = if rng.gen_bool(0.2) {
1144 None
1145 } else {
1146 Some(rng.gen_range(0.0..=100.0))
1147 };
1148 log::info!("Setting wrap width to {:?}", wrap_width);
1149 wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
1150 }
1151 20..=39 => {
1152 let block_count = rng.gen_range(1..=5);
1153 let block_properties = (0..block_count)
1154 .map(|_| {
1155 let buffer = buffer.read(cx).read(cx);
1156 let position = buffer.anchor_after(
1157 buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Left),
1158 );
1159
1160 let disposition = if rng.gen() {
1161 BlockDisposition::Above
1162 } else {
1163 BlockDisposition::Below
1164 };
1165 let height = rng.gen_range(1..5);
1166 log::info!(
1167 "inserting block {:?} {:?} with height {}",
1168 disposition,
1169 position.to_point(&buffer),
1170 height
1171 );
1172 BlockProperties {
1173 position,
1174 height,
1175 disposition,
1176 render: Arc::new(|_| Empty::new().boxed()),
1177 }
1178 })
1179 .collect::<Vec<_>>();
1180
1181 let (folds_snapshot, fold_edits) =
1182 fold_map.read(buffer_snapshot.clone(), vec![]);
1183 let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1184 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1185 wrap_map.sync(tabs_snapshot, tab_edits, cx)
1186 });
1187 let mut block_map = block_map.write(wraps_snapshot, wrap_edits);
1188 let block_ids = block_map.insert(block_properties.clone());
1189 for (block_id, props) in block_ids.into_iter().zip(block_properties) {
1190 expected_blocks.push((block_id, props));
1191 }
1192 }
1193 40..=59 if !expected_blocks.is_empty() => {
1194 let block_count = rng.gen_range(1..=4.min(expected_blocks.len()));
1195 let block_ids_to_remove = (0..block_count)
1196 .map(|_| {
1197 expected_blocks
1198 .remove(rng.gen_range(0..expected_blocks.len()))
1199 .0
1200 })
1201 .collect();
1202
1203 let (folds_snapshot, fold_edits) =
1204 fold_map.read(buffer_snapshot.clone(), vec![]);
1205 let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1206 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1207 wrap_map.sync(tabs_snapshot, tab_edits, cx)
1208 });
1209 let mut block_map = block_map.write(wraps_snapshot, wrap_edits);
1210 block_map.remove(block_ids_to_remove);
1211 }
1212 _ => {
1213 buffer.update(cx, |buffer, cx| {
1214 let edit_count = rng.gen_range(1..=5);
1215 let subscription = buffer.subscribe();
1216 buffer.randomly_edit(&mut rng, edit_count, cx);
1217 buffer_snapshot = buffer.snapshot(cx);
1218 buffer_edits.extend(subscription.consume());
1219 log::info!("buffer text: {:?}", buffer_snapshot.text());
1220 });
1221 }
1222 }
1223
1224 let (folds_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
1225 let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1226 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1227 wrap_map.sync(tabs_snapshot, tab_edits, cx)
1228 });
1229 let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits);
1230 assert_eq!(
1231 blocks_snapshot.transforms.summary().input_rows,
1232 wraps_snapshot.max_point().row() + 1
1233 );
1234 log::info!("blocks text: {:?}", blocks_snapshot.text());
1235
1236 let mut sorted_blocks = expected_blocks
1237 .iter()
1238 .cloned()
1239 .map(|(id, block)| {
1240 let mut position = block.position.to_point(&buffer_snapshot);
1241 let column = wraps_snapshot.from_point(position, Bias::Left).column();
1242 match block.disposition {
1243 BlockDisposition::Above => {
1244 position.column = 0;
1245 }
1246 BlockDisposition::Below => {
1247 position.column = buffer_snapshot.line_len(position.row);
1248 }
1249 };
1250 let row = wraps_snapshot.from_point(position, Bias::Left).row();
1251 (
1252 id,
1253 BlockProperties {
1254 position: BlockPoint::new(row, column),
1255 height: block.height,
1256 disposition: block.disposition,
1257 render: block.render.clone(),
1258 },
1259 )
1260 })
1261 .collect::<Vec<_>>();
1262 sorted_blocks
1263 .sort_unstable_by_key(|(id, block)| (block.position.row, block.disposition, *id));
1264 let mut sorted_blocks = sorted_blocks.into_iter().peekable();
1265
1266 let mut expected_buffer_rows = Vec::new();
1267 let mut expected_text = String::new();
1268 let input_text = wraps_snapshot.text();
1269 for (row, input_line) in input_text.split('\n').enumerate() {
1270 let row = row as u32;
1271 if row > 0 {
1272 expected_text.push('\n');
1273 }
1274
1275 let buffer_row = wraps_snapshot
1276 .to_point(WrapPoint::new(row, 0), Bias::Left)
1277 .row;
1278
1279 while let Some((_, block)) = sorted_blocks.peek() {
1280 if block.position.row == row && block.disposition == BlockDisposition::Above {
1281 let text = "\n".repeat(block.height as usize);
1282 expected_text.push_str(&text);
1283 for _ in 0..block.height {
1284 expected_buffer_rows.push(None);
1285 }
1286 sorted_blocks.next();
1287 } else {
1288 break;
1289 }
1290 }
1291
1292 let soft_wrapped = wraps_snapshot.to_tab_point(WrapPoint::new(row, 0)).column() > 0;
1293 expected_buffer_rows.push(if soft_wrapped { None } else { Some(buffer_row) });
1294 expected_text.push_str(input_line);
1295
1296 while let Some((_, block)) = sorted_blocks.peek() {
1297 if block.position.row == row && block.disposition == BlockDisposition::Below {
1298 let text = "\n".repeat(block.height as usize);
1299 expected_text.push_str(&text);
1300 for _ in 0..block.height {
1301 expected_buffer_rows.push(None);
1302 }
1303 sorted_blocks.next();
1304 } else {
1305 break;
1306 }
1307 }
1308 }
1309
1310 let expected_lines = expected_text.split('\n').collect::<Vec<_>>();
1311 let expected_row_count = expected_lines.len();
1312 for start_row in 0..expected_row_count {
1313 let expected_text = expected_lines[start_row..].join("\n");
1314 let actual_text = blocks_snapshot
1315 .chunks(start_row as u32..expected_row_count as u32, None)
1316 .map(|chunk| chunk.text)
1317 .collect::<String>();
1318 assert_eq!(
1319 actual_text, expected_text,
1320 "incorrect text starting from row {}",
1321 start_row
1322 );
1323 assert_eq!(
1324 blocks_snapshot
1325 .buffer_rows(start_row as u32)
1326 .collect::<Vec<_>>(),
1327 &expected_buffer_rows[start_row..]
1328 );
1329 }
1330
1331 let mut expected_longest_rows = Vec::new();
1332 let mut longest_line_len = -1_isize;
1333 for (row, line) in expected_lines.iter().enumerate() {
1334 let row = row as u32;
1335
1336 assert_eq!(
1337 blocks_snapshot.line_len(row),
1338 line.len() as u32,
1339 "invalid line len for row {}",
1340 row
1341 );
1342
1343 let line_char_count = line.chars().count() as isize;
1344 match line_char_count.cmp(&longest_line_len) {
1345 Ordering::Less => {}
1346 Ordering::Equal => expected_longest_rows.push(row),
1347 Ordering::Greater => {
1348 longest_line_len = line_char_count;
1349 expected_longest_rows.clear();
1350 expected_longest_rows.push(row);
1351 }
1352 }
1353 }
1354
1355 let longest_row = blocks_snapshot.longest_row();
1356 assert!(
1357 expected_longest_rows.contains(&longest_row),
1358 "incorrect longest row {}. expected {:?} with length {}",
1359 longest_row,
1360 expected_longest_rows,
1361 longest_line_len,
1362 );
1363
1364 for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row() {
1365 let wrap_point = WrapPoint::new(row, 0);
1366 let block_point = blocks_snapshot.to_block_point(wrap_point);
1367 assert_eq!(blocks_snapshot.to_wrap_point(block_point), wrap_point);
1368 }
1369
1370 let mut block_point = BlockPoint::new(0, 0);
1371 for c in expected_text.chars() {
1372 let left_point = blocks_snapshot.clip_point(block_point, Bias::Left);
1373 let left_buffer_point = blocks_snapshot.to_point(left_point, Bias::Left);
1374 assert_eq!(
1375 blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(left_point)),
1376 left_point
1377 );
1378 assert_eq!(
1379 left_buffer_point,
1380 buffer_snapshot.clip_point(left_buffer_point, Bias::Right),
1381 "{:?} is not valid in buffer coordinates",
1382 left_point
1383 );
1384
1385 let right_point = blocks_snapshot.clip_point(block_point, Bias::Right);
1386 let right_buffer_point = blocks_snapshot.to_point(right_point, Bias::Right);
1387 assert_eq!(
1388 blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(right_point)),
1389 right_point
1390 );
1391 assert_eq!(
1392 right_buffer_point,
1393 buffer_snapshot.clip_point(right_buffer_point, Bias::Left),
1394 "{:?} is not valid in buffer coordinates",
1395 right_point
1396 );
1397
1398 if c == '\n' {
1399 block_point.0 += Point::new(1, 0);
1400 } else {
1401 block_point.column += c.len_utf8() as u32;
1402 }
1403 }
1404 }
1405 }
1406
1407 impl BlockSnapshot {
1408 fn to_point(&self, point: BlockPoint, bias: Bias) -> Point {
1409 self.wrap_snapshot.to_point(self.to_wrap_point(point), bias)
1410 }
1411 }
1412}