diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rs index 3a1288248e..f7660ad2b3 100644 --- a/crates/editor/src/display_map.rs +++ b/crates/editor/src/display_map.rs @@ -1,12 +1,11 @@ mod block_map; mod fold_map; mod inlay_map; -mod suggestion_map; mod tab_map; mod wrap_map; use crate::{ - inlay_cache::{Inlay, InlayId, InlayProperties}, + inlay_cache::{InlayId, InlayProperties}, Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint, }; pub use block_map::{BlockMap, BlockPoint}; @@ -22,8 +21,6 @@ use language::{ language_settings::language_settings, OffsetUtf16, Point, Subscription as BufferSubscription, }; use std::{any::TypeId, fmt::Debug, num::NonZeroU32, ops::Range, sync::Arc}; -pub use suggestion_map::Suggestion; -use suggestion_map::SuggestionMap; use sum_tree::{Bias, TreeMap}; use tab_map::TabMap; use text::Rope; @@ -50,7 +47,6 @@ pub struct DisplayMap { buffer: ModelHandle, buffer_subscription: BufferSubscription, fold_map: FoldMap, - suggestion_map: SuggestionMap, inlay_map: InlayMap, tab_map: TabMap, wrap_map: ModelHandle, @@ -77,7 +73,6 @@ impl DisplayMap { let tab_size = Self::tab_size(&buffer, cx); let (fold_map, snapshot) = FoldMap::new(buffer.read(cx).snapshot(cx)); - let (suggestion_map, snapshot) = SuggestionMap::new(snapshot); let (inlay_map, snapshot) = InlayMap::new(snapshot); let (tab_map, snapshot) = TabMap::new(snapshot, tab_size); let (wrap_map, snapshot) = WrapMap::new(snapshot, font_id, font_size, wrap_width, cx); @@ -87,7 +82,6 @@ impl DisplayMap { buffer, buffer_subscription, fold_map, - suggestion_map, inlay_map, tab_map, wrap_map, @@ -101,8 +95,7 @@ impl DisplayMap { let buffer_snapshot = self.buffer.read(cx).snapshot(cx); let edits = self.buffer_subscription.consume().into_inner(); let (fold_snapshot, edits) = self.fold_map.read(buffer_snapshot, edits); - let (suggestion_snapshot, edits) = self.suggestion_map.sync(fold_snapshot.clone(), edits); - let (inlay_snapshot, edits) = self.inlay_map.sync(suggestion_snapshot.clone(), edits); + let (inlay_snapshot, edits) = self.inlay_map.sync(fold_snapshot.clone(), edits); let tab_size = Self::tab_size(&self.buffer, cx); let (tab_snapshot, edits) = self.tab_map.sync(inlay_snapshot.clone(), edits, tab_size); let (wrap_snapshot, edits) = self @@ -113,7 +106,6 @@ impl DisplayMap { DisplaySnapshot { buffer_snapshot: self.buffer.read(cx).snapshot(cx), fold_snapshot, - suggestion_snapshot, inlay_snapshot, tab_snapshot, wrap_snapshot, @@ -141,7 +133,6 @@ impl DisplayMap { let edits = self.buffer_subscription.consume().into_inner(); let tab_size = Self::tab_size(&self.buffer, cx); let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits); - let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits); let (snapshot, edits) = self.inlay_map.sync(snapshot, edits); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self @@ -149,7 +140,6 @@ impl DisplayMap { .update(cx, |map, cx| map.sync(snapshot, edits, cx)); self.block_map.read(snapshot, edits); let (snapshot, edits) = fold_map.fold(ranges); - let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits); let (snapshot, edits) = self.inlay_map.sync(snapshot, edits); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self @@ -168,7 +158,6 @@ impl DisplayMap { let edits = self.buffer_subscription.consume().into_inner(); let tab_size = Self::tab_size(&self.buffer, cx); let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits); - let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits); let (snapshot, edits) = self.inlay_map.sync(snapshot, edits); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self @@ -176,7 +165,6 @@ impl DisplayMap { .update(cx, |map, cx| map.sync(snapshot, edits, cx)); self.block_map.read(snapshot, edits); let (snapshot, edits) = fold_map.unfold(ranges, inclusive); - let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits); let (snapshot, edits) = self.inlay_map.sync(snapshot, edits); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self @@ -194,7 +182,6 @@ impl DisplayMap { let edits = self.buffer_subscription.consume().into_inner(); let tab_size = Self::tab_size(&self.buffer, cx); let (snapshot, edits) = self.fold_map.read(snapshot, edits); - let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits); let (snapshot, edits) = self.inlay_map.sync(snapshot, edits); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self @@ -213,7 +200,6 @@ impl DisplayMap { let edits = self.buffer_subscription.consume().into_inner(); let tab_size = Self::tab_size(&self.buffer, cx); let (snapshot, edits) = self.fold_map.read(snapshot, edits); - let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits); let (snapshot, edits) = self.inlay_map.sync(snapshot, edits); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self @@ -269,7 +255,6 @@ impl DisplayMap { let edits = self.buffer_subscription.consume().into_inner(); let tab_size = Self::tab_size(&self.buffer, cx); let (snapshot, edits) = self.fold_map.read(buffer_snapshot.clone(), edits); - let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits); let (snapshot, edits) = self.inlay_map.sync(snapshot, edits); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self @@ -302,7 +287,6 @@ impl DisplayMap { pub struct DisplaySnapshot { pub buffer_snapshot: MultiBufferSnapshot, fold_snapshot: fold_map::FoldSnapshot, - suggestion_snapshot: suggestion_map::SuggestionSnapshot, inlay_snapshot: inlay_map::InlaySnapshot, tab_snapshot: tab_map::TabSnapshot, wrap_snapshot: wrap_map::WrapSnapshot, @@ -380,8 +364,7 @@ impl DisplaySnapshot { fn point_to_display_point(&self, point: Point, bias: Bias) -> DisplayPoint { let fold_point = self.fold_snapshot.to_fold_point(point, bias); - let suggestion_point = self.suggestion_snapshot.to_suggestion_point(fold_point); - let inlay_point = self.inlay_snapshot.to_inlay_point(suggestion_point); + let inlay_point = self.inlay_snapshot.to_inlay_point(fold_point); let tab_point = self.tab_snapshot.to_tab_point(inlay_point); let wrap_point = self.wrap_snapshot.tab_point_to_wrap_point(tab_point); let block_point = self.block_snapshot.to_block_point(wrap_point); @@ -393,8 +376,7 @@ impl DisplaySnapshot { let wrap_point = self.block_snapshot.to_wrap_point(block_point); let tab_point = self.wrap_snapshot.to_tab_point(wrap_point); let inlay_point = self.tab_snapshot.to_inlay_point(tab_point, bias).0; - let suggestion_point = self.inlay_snapshot.to_suggestion_point(inlay_point); - let fold_point = self.suggestion_snapshot.to_fold_point(suggestion_point); + let fold_point = self.inlay_snapshot.to_fold_point(inlay_point); fold_point.to_buffer_point(&self.fold_snapshot) } @@ -808,8 +790,7 @@ impl DisplayPoint { let wrap_point = map.block_snapshot.to_wrap_point(self.0); let tab_point = map.wrap_snapshot.to_tab_point(wrap_point); let inlay_point = map.tab_snapshot.to_inlay_point(tab_point, bias).0; - let suggestion_point = map.inlay_snapshot.to_suggestion_point(inlay_point); - let fold_point = map.suggestion_snapshot.to_fold_point(suggestion_point); + let fold_point = map.inlay_snapshot.to_fold_point(inlay_point); fold_point.to_buffer_offset(&map.fold_snapshot) } } diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs index 85d5275dd3..3bb8ccc2ac 100644 --- a/crates/editor/src/display_map/block_map.rs +++ b/crates/editor/src/display_map/block_map.rs @@ -990,7 +990,6 @@ fn offset_for_row(s: &str, target: u32) -> (u32, usize) { mod tests { use super::*; use crate::display_map::inlay_map::InlayMap; - use crate::display_map::suggestion_map::SuggestionMap; use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap}; use crate::multi_buffer::MultiBuffer; use gpui::{elements::Empty, Element}; @@ -1032,8 +1031,7 @@ mod tests { let buffer_snapshot = buffer.read(cx).snapshot(cx); let subscription = buffer.update(cx, |buffer, _| buffer.subscribe()); let (fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); - let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); - let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot); + let (mut inlay_map, inlay_snapshot) = InlayMap::new(fold_snapshot); let (tab_map, tab_snapshot) = TabMap::new(inlay_snapshot, 1.try_into().unwrap()); let (wrap_map, wraps_snapshot) = WrapMap::new(tab_snapshot, font_id, 14.0, None, cx); let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1); @@ -1179,9 +1177,7 @@ mod tests { let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot, subscription.consume().into_inner()); - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot, fold_edits); - let (inlay_snapshot, inlay_edits) = inlay_map.sync(suggestion_snapshot, suggestion_edits); + let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits); let (tab_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, 4.try_into().unwrap()); let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| { @@ -1209,8 +1205,7 @@ mod tests { let buffer = MultiBuffer::build_simple(text, cx); let buffer_snapshot = buffer.read(cx).snapshot(cx); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); - let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); - let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot); + let (_, inlay_snapshot) = InlayMap::new(fold_snapshot); let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); let (_, wraps_snapshot) = WrapMap::new(tab_snapshot, font_id, 14.0, Some(60.), cx); let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1); @@ -1282,8 +1277,7 @@ mod tests { let mut buffer_snapshot = buffer.read(cx).snapshot(cx); let (fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); - let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); - let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot); + let (mut inlay_map, inlay_snapshot) = InlayMap::new(fold_snapshot); let (tab_map, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); let (wrap_map, wraps_snapshot) = WrapMap::new(tab_snapshot, font_id, font_size, wrap_width, cx); @@ -1339,10 +1333,7 @@ mod tests { let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), vec![]); - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot, fold_edits); - let (inlay_snapshot, inlay_edits) = - inlay_map.sync(suggestion_snapshot, suggestion_edits); + let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits); let (tab_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size); let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| { @@ -1366,10 +1357,7 @@ mod tests { let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), vec![]); - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot, fold_edits); - let (inlay_snapshot, inlay_edits) = - inlay_map.sync(suggestion_snapshot, suggestion_edits); + let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits); let (tab_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size); let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| { @@ -1391,10 +1379,7 @@ mod tests { } let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits); - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot, fold_edits); - let (inlay_snapshot, inlay_edits) = - inlay_map.sync(suggestion_snapshot, suggestion_edits); + let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits); let (tab_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size); let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| { wrap_map.sync(tab_snapshot, tab_edits, cx) diff --git a/crates/editor/src/display_map/fold_map.rs b/crates/editor/src/display_map/fold_map.rs index 36cfeba4a1..5e4eeca454 100644 --- a/crates/editor/src/display_map/fold_map.rs +++ b/crates/editor/src/display_map/fold_map.rs @@ -11,7 +11,7 @@ use std::{ any::TypeId, cmp::{self, Ordering}, iter::{self, Peekable}, - ops::{Range, Sub}, + ops::{Add, AddAssign, Range, Sub}, sync::atomic::{AtomicUsize, Ordering::SeqCst}, vec, }; @@ -508,6 +508,10 @@ impl FoldSnapshot { self.folds.items(&self.buffer_snapshot).len() } + pub fn text_summary(&self) -> TextSummary { + self.transforms.summary().output.clone() + } + pub fn text_summary_for_range(&self, range: Range) -> TextSummary { let mut summary = TextSummary::default(); @@ -1170,6 +1174,20 @@ impl FoldOffset { } } +impl Add for FoldOffset { + type Output = Self; + + fn add(self, rhs: Self) -> Self::Output { + Self(self.0 + rhs.0) + } +} + +impl AddAssign for FoldOffset { + fn add_assign(&mut self, rhs: Self) { + self.0 += rhs.0; + } +} + impl Sub for FoldOffset { type Output = Self; diff --git a/crates/editor/src/display_map/inlay_map.rs b/crates/editor/src/display_map/inlay_map.rs index 5284c0bd80..615d08fa87 100644 --- a/crates/editor/src/display_map/inlay_map.rs +++ b/crates/editor/src/display_map/inlay_map.rs @@ -1,8 +1,5 @@ use super::{ - suggestion_map::{ - SuggestionBufferRows, SuggestionChunks, SuggestionEdit, SuggestionOffset, SuggestionPoint, - SuggestionSnapshot, - }, + fold_map::{FoldBufferRows, FoldChunks, FoldEdit, FoldOffset, FoldPoint, FoldSnapshot}, TextHighlights, }; use crate::{ @@ -29,7 +26,7 @@ pub struct InlayMap { #[derive(Clone)] pub struct InlaySnapshot { // TODO kb merge these two together - pub suggestion_snapshot: SuggestionSnapshot, + pub fold_snapshot: FoldSnapshot, transforms: SumTree, pub version: usize, } @@ -105,7 +102,7 @@ impl<'a> sum_tree::Dimension<'a, TransformSummary> for InlayOffset { } } -impl<'a> sum_tree::Dimension<'a, TransformSummary> for SuggestionOffset { +impl<'a> sum_tree::Dimension<'a, TransformSummary> for FoldOffset { fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { self.0 += &summary.input.len; } @@ -120,7 +117,7 @@ impl<'a> sum_tree::Dimension<'a, TransformSummary> for InlayPoint { } } -impl<'a> sum_tree::Dimension<'a, TransformSummary> for SuggestionPoint { +impl<'a> sum_tree::Dimension<'a, TransformSummary> for FoldPoint { fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { self.0 += &summary.input.lines; } @@ -128,15 +125,15 @@ impl<'a> sum_tree::Dimension<'a, TransformSummary> for SuggestionPoint { #[derive(Clone)] pub struct InlayBufferRows<'a> { - transforms: Cursor<'a, Transform, (InlayPoint, SuggestionPoint)>, - suggestion_rows: SuggestionBufferRows<'a>, + transforms: Cursor<'a, Transform, (InlayPoint, FoldPoint)>, + fold_rows: FoldBufferRows<'a>, inlay_row: u32, } pub struct InlayChunks<'a> { - transforms: Cursor<'a, Transform, (InlayOffset, SuggestionOffset)>, - suggestion_chunks: SuggestionChunks<'a>, - suggestion_chunk: Option>, + transforms: Cursor<'a, Transform, (InlayOffset, FoldOffset)>, + fold_chunks: FoldChunks<'a>, + fold_chunk: Option>, inlay_chunks: Option>, output_offset: InlayOffset, max_output_offset: InlayOffset, @@ -154,10 +151,10 @@ impl<'a> Iterator for InlayChunks<'a> { let chunk = match self.transforms.item()? { Transform::Isomorphic(_) => { let chunk = self - .suggestion_chunk - .get_or_insert_with(|| self.suggestion_chunks.next().unwrap()); + .fold_chunk + .get_or_insert_with(|| self.fold_chunks.next().unwrap()); if chunk.text.is_empty() { - *chunk = self.suggestion_chunks.next().unwrap(); + *chunk = self.fold_chunks.next().unwrap(); } let (prefix, suffix) = chunk.text.split_at(cmp::min( @@ -204,11 +201,11 @@ impl<'a> Iterator for InlayBufferRows<'a> { fn next(&mut self) -> Option { let buffer_row = if self.inlay_row == 0 { - self.suggestion_rows.next().unwrap() + self.fold_rows.next().unwrap() } else { match self.transforms.item()? { Transform::Inlay(_) => None, - Transform::Isomorphic(_) => self.suggestion_rows.next().unwrap(), + Transform::Isomorphic(_) => self.fold_rows.next().unwrap(), } }; @@ -235,12 +232,12 @@ impl InlayPoint { } impl InlayMap { - pub fn new(suggestion_snapshot: SuggestionSnapshot) -> (Self, InlaySnapshot) { + pub fn new(fold_snapshot: FoldSnapshot) -> (Self, InlaySnapshot) { let snapshot = InlaySnapshot { - suggestion_snapshot: suggestion_snapshot.clone(), + fold_snapshot: fold_snapshot.clone(), version: 0, transforms: SumTree::from_item( - Transform::Isomorphic(suggestion_snapshot.text_summary()), + Transform::Isomorphic(fold_snapshot.text_summary()), &(), ), }; @@ -257,45 +254,40 @@ impl InlayMap { pub fn sync( &mut self, - suggestion_snapshot: SuggestionSnapshot, - mut suggestion_edits: Vec, + fold_snapshot: FoldSnapshot, + mut fold_edits: Vec, ) -> (InlaySnapshot, Vec) { let mut snapshot = self.snapshot.lock(); let mut new_snapshot = snapshot.clone(); - if new_snapshot.suggestion_snapshot.version != suggestion_snapshot.version { + if new_snapshot.fold_snapshot.version != fold_snapshot.version { new_snapshot.version += 1; } - if suggestion_snapshot + if fold_snapshot .buffer_snapshot() .trailing_excerpt_update_count() != snapshot - .suggestion_snapshot + .fold_snapshot .buffer_snapshot() .trailing_excerpt_update_count() { - if suggestion_edits.is_empty() { - suggestion_edits.push(Edit { - old: snapshot.suggestion_snapshot.len()..snapshot.suggestion_snapshot.len(), - new: suggestion_snapshot.len()..suggestion_snapshot.len(), + if fold_edits.is_empty() { + fold_edits.push(Edit { + old: snapshot.fold_snapshot.len()..snapshot.fold_snapshot.len(), + new: fold_snapshot.len()..fold_snapshot.len(), }); } } let mut inlay_edits = Patch::default(); let mut new_transforms = SumTree::new(); - let mut cursor = snapshot - .transforms - .cursor::<(SuggestionOffset, InlayOffset)>(); - let mut suggestion_edits_iter = suggestion_edits.iter().peekable(); - while let Some(suggestion_edit) = suggestion_edits_iter.next() { - new_transforms.push_tree( - cursor.slice(&suggestion_edit.old.start, Bias::Left, &()), - &(), - ); + let mut cursor = snapshot.transforms.cursor::<(FoldOffset, InlayOffset)>(); + let mut fold_edits_iter = fold_edits.iter().peekable(); + while let Some(fold_edit) = fold_edits_iter.next() { + new_transforms.push_tree(cursor.slice(&fold_edit.old.start, Bias::Left, &()), &()); if let Some(Transform::Isomorphic(transform)) = cursor.item() { - if cursor.end(&()).0 == suggestion_edit.old.start { + if cursor.end(&()).0 == fold_edit.old.start { new_transforms.push(Transform::Isomorphic(transform.clone()), &()); cursor.next(&()); } @@ -303,30 +295,30 @@ impl InlayMap { // Remove all the inlays and transforms contained by the edit. let old_start = - cursor.start().1 + InlayOffset(suggestion_edit.old.start.0 - cursor.start().0 .0); - cursor.seek(&suggestion_edit.old.end, Bias::Right, &()); - let old_end = - cursor.start().1 + InlayOffset(suggestion_edit.old.end.0 - cursor.start().0 .0); + cursor.start().1 + InlayOffset(fold_edit.old.start.0 - cursor.start().0 .0); + cursor.seek(&fold_edit.old.end, Bias::Right, &()); + let old_end = cursor.start().1 + InlayOffset(fold_edit.old.end.0 - cursor.start().0 .0); // Push the unchanged prefix. - let prefix_start = SuggestionOffset(new_transforms.summary().input.len); - let prefix_end = suggestion_edit.new.start; + let prefix_start = FoldOffset(new_transforms.summary().input.len); + let prefix_end = fold_edit.new.start; push_isomorphic( &mut new_transforms, - suggestion_snapshot.text_summary_for_range( - suggestion_snapshot.to_point(prefix_start) - ..suggestion_snapshot.to_point(prefix_end), + fold_snapshot.text_summary_for_range( + prefix_start.to_point(&fold_snapshot)..prefix_end.to_point(&fold_snapshot), ), ); let new_start = InlayOffset(new_transforms.summary().output.len); - let start_point = suggestion_snapshot - .to_fold_point(suggestion_snapshot.to_point(suggestion_edit.new.start)) - .to_buffer_point(&suggestion_snapshot.fold_snapshot); + let start_point = fold_edit + .new + .start + .to_point(&fold_snapshot) + .to_buffer_point(&fold_snapshot); let start_ix = match self.inlays.binary_search_by(|probe| { probe .position - .to_point(&suggestion_snapshot.buffer_snapshot()) + .to_point(&fold_snapshot.buffer_snapshot()) .cmp(&start_point) .then(std::cmp::Ordering::Greater) }) { @@ -334,43 +326,34 @@ impl InlayMap { }; for inlay in &self.inlays[start_ix..] { - let buffer_point = inlay - .position - .to_point(suggestion_snapshot.buffer_snapshot()); - let fold_point = suggestion_snapshot - .fold_snapshot - .to_fold_point(buffer_point, Bias::Left); - let suggestion_point = suggestion_snapshot.to_suggestion_point(fold_point); - let suggestion_offset = suggestion_snapshot.to_offset(suggestion_point); - if suggestion_offset > suggestion_edit.new.end { + let buffer_point = inlay.position.to_point(fold_snapshot.buffer_snapshot()); + let fold_point = fold_snapshot.to_fold_point(buffer_point, Bias::Left); + let fold_offset = fold_point.to_offset(&fold_snapshot); + if fold_offset > fold_edit.new.end { break; } - let prefix_start = SuggestionOffset(new_transforms.summary().input.len); - let prefix_end = suggestion_offset; + let prefix_start = FoldOffset(new_transforms.summary().input.len); + let prefix_end = fold_offset; push_isomorphic( &mut new_transforms, - suggestion_snapshot.text_summary_for_range( - suggestion_snapshot.to_point(prefix_start) - ..suggestion_snapshot.to_point(prefix_end), + fold_snapshot.text_summary_for_range( + prefix_start.to_point(&fold_snapshot)..prefix_end.to_point(&fold_snapshot), ), ); - if inlay - .position - .is_valid(suggestion_snapshot.buffer_snapshot()) - { + if inlay.position.is_valid(fold_snapshot.buffer_snapshot()) { new_transforms.push(Transform::Inlay(inlay.clone()), &()); } } // Apply the rest of the edit. - let transform_start = SuggestionOffset(new_transforms.summary().input.len); + let transform_start = FoldOffset(new_transforms.summary().input.len); push_isomorphic( &mut new_transforms, - suggestion_snapshot.text_summary_for_range( - suggestion_snapshot.to_point(transform_start) - ..suggestion_snapshot.to_point(suggestion_edit.new.end), + fold_snapshot.text_summary_for_range( + transform_start.to_point(&fold_snapshot) + ..fold_edit.new.end.to_point(&fold_snapshot), ), ); let new_end = InlayOffset(new_transforms.summary().output.len); @@ -381,18 +364,17 @@ impl InlayMap { // If the next edit doesn't intersect the current isomorphic transform, then // we can push its remainder. - if suggestion_edits_iter + if fold_edits_iter .peek() .map_or(true, |edit| edit.old.start >= cursor.end(&()).0) { - let transform_start = SuggestionOffset(new_transforms.summary().input.len); - let transform_end = - suggestion_edit.new.end + (cursor.end(&()).0 - suggestion_edit.old.end); + let transform_start = FoldOffset(new_transforms.summary().input.len); + let transform_end = fold_edit.new.end + (cursor.end(&()).0 - fold_edit.old.end); push_isomorphic( &mut new_transforms, - suggestion_snapshot.text_summary_for_range( - suggestion_snapshot.to_point(transform_start) - ..suggestion_snapshot.to_point(transform_end), + fold_snapshot.text_summary_for_range( + transform_start.to_point(&fold_snapshot) + ..transform_end.to_point(&fold_snapshot), ), ); cursor.next(&()); @@ -404,7 +386,7 @@ impl InlayMap { new_transforms.push(Transform::Isomorphic(Default::default()), &()); } new_snapshot.transforms = new_transforms; - new_snapshot.suggestion_snapshot = suggestion_snapshot; + new_snapshot.fold_snapshot = fold_snapshot; new_snapshot.check_invariants(); drop(cursor); @@ -427,12 +409,10 @@ impl InlayMap { if let Some(inlay) = self.inlays_by_id.remove(&inlay_id) { let buffer_point = inlay.position.to_point(snapshot.buffer_snapshot()); let fold_point = snapshot - .suggestion_snapshot .fold_snapshot .to_fold_point(buffer_point, Bias::Left); - let suggestion_point = snapshot.suggestion_snapshot.to_suggestion_point(fold_point); - let suggestion_offset = snapshot.suggestion_snapshot.to_offset(suggestion_point); - edits.insert(suggestion_offset); + let fold_offset = fold_point.to_offset(&snapshot.fold_snapshot); + edits.insert(fold_offset); } } @@ -455,16 +435,14 @@ impl InlayMap { let buffer_point = inlay.position.to_point(snapshot.buffer_snapshot()); let fold_point = snapshot - .suggestion_snapshot .fold_snapshot .to_fold_point(buffer_point, Bias::Left); - let suggestion_point = snapshot.suggestion_snapshot.to_suggestion_point(fold_point); - let suggestion_offset = snapshot.suggestion_snapshot.to_offset(suggestion_point); - edits.insert(suggestion_offset); + let fold_offset = fold_point.to_offset(&snapshot.fold_snapshot); + edits.insert(fold_offset); } - let suggestion_snapshot = snapshot.suggestion_snapshot.clone(); - let suggestion_edits = edits + let fold_snapshot = snapshot.fold_snapshot.clone(); + let fold_edits = edits .into_iter() .map(|offset| Edit { old: offset..offset, @@ -472,11 +450,11 @@ impl InlayMap { }) .collect(); drop(snapshot); - self.sync(suggestion_snapshot, suggestion_edits) + self.sync(fold_snapshot, fold_edits) } #[cfg(any(test, feature = "test-support"))] - pub fn randomly_mutate( + pub(crate) fn randomly_mutate( &mut self, next_inlay_id: &mut usize, rng: &mut rand::rngs::StdRng, @@ -522,22 +500,22 @@ impl InlayMap { impl InlaySnapshot { pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot { - self.suggestion_snapshot.buffer_snapshot() + self.fold_snapshot.buffer_snapshot() } pub fn to_point(&self, offset: InlayOffset) -> InlayPoint { let mut cursor = self .transforms - .cursor::<(InlayOffset, (InlayPoint, SuggestionOffset))>(); + .cursor::<(InlayOffset, (InlayPoint, FoldOffset))>(); cursor.seek(&offset, Bias::Right, &()); let overshoot = offset.0 - cursor.start().0 .0; match cursor.item() { Some(Transform::Isomorphic(_)) => { - let suggestion_offset_start = cursor.start().1 .1; - let suggestion_offset_end = SuggestionOffset(suggestion_offset_start.0 + overshoot); - let suggestion_start = self.suggestion_snapshot.to_point(suggestion_offset_start); - let suggestion_end = self.suggestion_snapshot.to_point(suggestion_offset_end); - InlayPoint(cursor.start().1 .0 .0 + (suggestion_end.0 - suggestion_start.0)) + let fold_offset_start = cursor.start().1 .1; + let fold_offset_end = FoldOffset(fold_offset_start.0 + overshoot); + let fold_start = fold_offset_start.to_point(&self.fold_snapshot); + let fold_end = fold_offset_end.to_point(&self.fold_snapshot); + InlayPoint(cursor.start().1 .0 .0 + (fold_end.0 - fold_start.0)) } Some(Transform::Inlay(inlay)) => { let overshoot = inlay.text.offset_to_point(overshoot); @@ -558,16 +536,16 @@ impl InlaySnapshot { pub fn to_offset(&self, point: InlayPoint) -> InlayOffset { let mut cursor = self .transforms - .cursor::<(InlayPoint, (InlayOffset, SuggestionPoint))>(); + .cursor::<(InlayPoint, (InlayOffset, FoldPoint))>(); cursor.seek(&point, Bias::Right, &()); let overshoot = point.0 - cursor.start().0 .0; match cursor.item() { Some(Transform::Isomorphic(_)) => { - let suggestion_point_start = cursor.start().1 .1; - let suggestion_point_end = SuggestionPoint(suggestion_point_start.0 + overshoot); - let suggestion_start = self.suggestion_snapshot.to_offset(suggestion_point_start); - let suggestion_end = self.suggestion_snapshot.to_offset(suggestion_point_end); - InlayOffset(cursor.start().1 .0 .0 + (suggestion_end.0 - suggestion_start.0)) + let fold_point_start = cursor.start().1 .1; + let fold_point_end = FoldPoint(fold_point_start.0 + overshoot); + let fold_start = fold_point_start.to_offset(&self.fold_snapshot); + let fold_end = fold_point_end.to_offset(&self.fold_snapshot); + InlayOffset(cursor.start().1 .0 .0 + (fold_end.0 - fold_start.0)) } Some(Transform::Inlay(inlay)) => { let overshoot = inlay.text.point_to_offset(overshoot); @@ -582,34 +560,34 @@ impl InlaySnapshot { .flat_map(|chunk| chunk.text.chars()) } - pub fn to_suggestion_point(&self, point: InlayPoint) -> SuggestionPoint { - let mut cursor = self.transforms.cursor::<(InlayPoint, SuggestionPoint)>(); + pub fn to_fold_point(&self, point: InlayPoint) -> FoldPoint { + let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>(); cursor.seek(&point, Bias::Right, &()); match cursor.item() { Some(Transform::Isomorphic(_)) => { let overshoot = point.0 - cursor.start().0 .0; - SuggestionPoint(cursor.start().1 .0 + overshoot) + FoldPoint(cursor.start().1 .0 + overshoot) } Some(Transform::Inlay(_)) => cursor.start().1, - None => self.suggestion_snapshot.max_point(), + None => self.fold_snapshot.max_point(), } } - pub fn to_suggestion_offset(&self, offset: InlayOffset) -> SuggestionOffset { - let mut cursor = self.transforms.cursor::<(InlayOffset, SuggestionOffset)>(); + pub fn to_fold_offset(&self, offset: InlayOffset) -> FoldOffset { + let mut cursor = self.transforms.cursor::<(InlayOffset, FoldOffset)>(); cursor.seek(&offset, Bias::Right, &()); match cursor.item() { Some(Transform::Isomorphic(_)) => { let overshoot = offset - cursor.start().0; - cursor.start().1 + SuggestionOffset(overshoot.0) + cursor.start().1 + FoldOffset(overshoot.0) } Some(Transform::Inlay(_)) => cursor.start().1, - None => self.suggestion_snapshot.len(), + None => self.fold_snapshot.len(), } } - pub fn to_inlay_point(&self, point: SuggestionPoint) -> InlayPoint { - let mut cursor = self.transforms.cursor::<(SuggestionPoint, InlayPoint)>(); + pub fn to_inlay_point(&self, point: FoldPoint) -> InlayPoint { + let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(); cursor.seek(&point, Bias::Left, &()); match cursor.item() { Some(Transform::Isomorphic(_)) => { @@ -622,7 +600,7 @@ impl InlaySnapshot { } pub fn clip_point(&self, point: InlayPoint, bias: Bias) -> InlayPoint { - let mut cursor = self.transforms.cursor::<(InlayPoint, SuggestionPoint)>(); + let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>(); cursor.seek(&point, Bias::Left, &()); let mut bias = bias; @@ -644,10 +622,9 @@ impl InlaySnapshot { } else { point.0 - cursor.start().0 .0 }; - let suggestion_point = SuggestionPoint(cursor.start().1 .0 + overshoot); - let clipped_suggestion_point = - self.suggestion_snapshot.clip_point(suggestion_point, bias); - let clipped_overshoot = clipped_suggestion_point.0 - cursor.start().1 .0; + let fold_point = FoldPoint(cursor.start().1 .0 + overshoot); + let clipped_fold_point = self.fold_snapshot.clip_point(fold_point, bias); + let clipped_overshoot = clipped_fold_point.0 - cursor.start().1 .0; return InlayPoint(cursor.start().0 .0 + clipped_overshoot); } Some(Transform::Inlay(_)) => skipped_inlay = true, @@ -668,20 +645,19 @@ impl InlaySnapshot { pub fn text_summary_for_range(&self, range: Range) -> TextSummary { let mut summary = TextSummary::default(); - let mut cursor = self.transforms.cursor::<(InlayPoint, SuggestionPoint)>(); + let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>(); cursor.seek(&range.start, Bias::Right, &()); let overshoot = range.start.0 - cursor.start().0 .0; match cursor.item() { Some(Transform::Isomorphic(_)) => { - let suggestion_start = cursor.start().1 .0; - let suffix_start = SuggestionPoint(suggestion_start + overshoot); - let suffix_end = SuggestionPoint( - suggestion_start - + (cmp::min(cursor.end(&()).0, range.end).0 - cursor.start().0 .0), + let fold_start = cursor.start().1 .0; + let suffix_start = FoldPoint(fold_start + overshoot); + let suffix_end = FoldPoint( + fold_start + (cmp::min(cursor.end(&()).0, range.end).0 - cursor.start().0 .0), ); summary = self - .suggestion_snapshot + .fold_snapshot .text_summary_for_range(suffix_start..suffix_end); cursor.next(&()); } @@ -705,9 +681,9 @@ impl InlaySnapshot { match cursor.item() { Some(Transform::Isomorphic(_)) => { let prefix_start = cursor.start().1; - let prefix_end = SuggestionPoint(prefix_start.0 + overshoot); + let prefix_end = FoldPoint(prefix_start.0 + overshoot); summary += self - .suggestion_snapshot + .fold_snapshot .text_summary_for_range(prefix_start..prefix_end); } Some(Transform::Inlay(inlay)) => { @@ -722,30 +698,27 @@ impl InlaySnapshot { } pub fn buffer_rows<'a>(&'a self, row: u32) -> InlayBufferRows<'a> { - let mut cursor = self.transforms.cursor::<(InlayPoint, SuggestionPoint)>(); + let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>(); let inlay_point = InlayPoint::new(row, 0); cursor.seek(&inlay_point, Bias::Left, &()); - let mut suggestion_point = cursor.start().1; - let suggestion_row = if row == 0 { + let mut fold_point = cursor.start().1; + let fold_row = if row == 0 { 0 } else { match cursor.item() { Some(Transform::Isomorphic(_)) => { - suggestion_point.0 += inlay_point.0 - cursor.start().0 .0; - suggestion_point.row() + fold_point.0 += inlay_point.0 - cursor.start().0 .0; + fold_point.row() } - _ => cmp::min( - suggestion_point.row() + 1, - self.suggestion_snapshot.max_point().row(), - ), + _ => cmp::min(fold_point.row() + 1, self.fold_snapshot.max_point().row()), } }; InlayBufferRows { transforms: cursor, inlay_row: inlay_point.row(), - suggestion_rows: self.suggestion_snapshot.buffer_rows(suggestion_row), + fold_rows: self.fold_snapshot.buffer_rows(fold_row), } } @@ -764,28 +737,24 @@ impl InlaySnapshot { range: Range, language_aware: bool, text_highlights: Option<&'a TextHighlights>, - suggestion_highlight: Option, + inlay_highlight_style: Option, ) -> InlayChunks<'a> { - let mut cursor = self.transforms.cursor::<(InlayOffset, SuggestionOffset)>(); + let mut cursor = self.transforms.cursor::<(InlayOffset, FoldOffset)>(); cursor.seek(&range.start, Bias::Right, &()); - let suggestion_range = - self.to_suggestion_offset(range.start)..self.to_suggestion_offset(range.end); - let suggestion_chunks = self.suggestion_snapshot.chunks( - suggestion_range, - language_aware, - text_highlights, - suggestion_highlight, - ); + let fold_range = self.to_fold_offset(range.start)..self.to_fold_offset(range.end); + let fold_chunks = self + .fold_snapshot + .chunks(fold_range, language_aware, text_highlights); InlayChunks { transforms: cursor, - suggestion_chunks, + fold_chunks, inlay_chunks: None, - suggestion_chunk: None, + fold_chunk: None, output_offset: range.start, max_output_offset: range.end, - highlight_style: suggestion_highlight, + highlight_style: inlay_highlight_style, } } @@ -801,7 +770,7 @@ impl InlaySnapshot { { assert_eq!( self.transforms.summary().input, - self.suggestion_snapshot.text_summary() + self.fold_snapshot.text_summary() ); } } @@ -830,10 +799,7 @@ fn push_isomorphic(sum_tree: &mut SumTree, summary: TextSummary) { #[cfg(test)] mod tests { use super::*; - use crate::{ - display_map::{fold_map::FoldMap, suggestion_map::SuggestionMap}, - MultiBuffer, - }; + use crate::{display_map::fold_map::FoldMap, MultiBuffer}; use gpui::AppContext; use rand::prelude::*; use settings::SettingsStore; @@ -846,8 +812,7 @@ mod tests { let buffer = MultiBuffer::build_simple("abcdefghi", cx); let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe()); let (fold_map, fold_snapshot) = FoldMap::new(buffer.read(cx).snapshot(cx)); - let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone()); - let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone()); + let (mut inlay_map, inlay_snapshot) = InlayMap::new(fold_snapshot.clone()); assert_eq!(inlay_snapshot.text(), "abcdefghi"); let mut next_inlay_id = 0; @@ -863,27 +828,27 @@ mod tests { ); assert_eq!(inlay_snapshot.text(), "abc|123|defghi"); assert_eq!( - inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 0)), + inlay_snapshot.to_inlay_point(FoldPoint::new(0, 0)), InlayPoint::new(0, 0) ); assert_eq!( - inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 1)), + inlay_snapshot.to_inlay_point(FoldPoint::new(0, 1)), InlayPoint::new(0, 1) ); assert_eq!( - inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 2)), + inlay_snapshot.to_inlay_point(FoldPoint::new(0, 2)), InlayPoint::new(0, 2) ); assert_eq!( - inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 3)), + inlay_snapshot.to_inlay_point(FoldPoint::new(0, 3)), InlayPoint::new(0, 3) ); assert_eq!( - inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 4)), + inlay_snapshot.to_inlay_point(FoldPoint::new(0, 4)), InlayPoint::new(0, 9) ); assert_eq!( - inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 5)), + inlay_snapshot.to_inlay_point(FoldPoint::new(0, 5)), InlayPoint::new(0, 10) ); assert_eq!( @@ -919,9 +884,7 @@ mod tests { buffer.read(cx).snapshot(cx), buffer_edits.consume().into_inner(), ); - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot.clone(), fold_edits); - let (inlay_snapshot, _) = inlay_map.sync(suggestion_snapshot.clone(), suggestion_edits); + let (inlay_snapshot, _) = inlay_map.sync(fold_snapshot.clone(), fold_edits); assert_eq!(inlay_snapshot.text(), "abxy|123|dzefghi"); // An edit surrounding the inlay should invalidate it. @@ -930,9 +893,7 @@ mod tests { buffer.read(cx).snapshot(cx), buffer_edits.consume().into_inner(), ); - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot.clone(), fold_edits); - let (inlay_snapshot, _) = inlay_map.sync(suggestion_snapshot.clone(), suggestion_edits); + let (inlay_snapshot, _) = inlay_map.sync(fold_snapshot.clone(), fold_edits); assert_eq!(inlay_snapshot.text(), "abxyDzefghi"); let (inlay_snapshot, _) = inlay_map.splice( @@ -962,9 +923,7 @@ mod tests { buffer.read(cx).snapshot(cx), buffer_edits.consume().into_inner(), ); - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot.clone(), fold_edits); - let (inlay_snapshot, _) = inlay_map.sync(suggestion_snapshot.clone(), suggestion_edits); + let (inlay_snapshot, _) = inlay_map.sync(fold_snapshot.clone(), fold_edits); assert_eq!(inlay_snapshot.text(), "abx|123|JKL|456|yDzefghi"); // The inlays can be manually removed. @@ -977,8 +936,7 @@ mod tests { fn test_buffer_rows(cx: &mut AppContext) { let buffer = MultiBuffer::build_simple("abc\ndef\nghi", cx); let (_, fold_snapshot) = FoldMap::new(buffer.read(cx).snapshot(cx)); - let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone()); - let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone()); + let (mut inlay_map, inlay_snapshot) = InlayMap::new(fold_snapshot.clone()); assert_eq!(inlay_snapshot.text(), "abc\ndef\nghi"); let (inlay_snapshot, _) = inlay_map.splice( @@ -1035,12 +993,11 @@ mod tests { log::info!("buffer text: {:?}", buffer_snapshot.text()); let (mut fold_map, mut fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); - let (suggestion_map, mut suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone()); - let (mut inlay_map, mut inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone()); + let (mut inlay_map, mut inlay_snapshot) = InlayMap::new(fold_snapshot.clone()); let mut next_inlay_id = 0; for _ in 0..operations { - let mut suggestion_edits = Patch::default(); + let mut fold_edits = Patch::default(); let mut inlay_edits = Patch::default(); let mut prev_inlay_text = inlay_snapshot.text(); @@ -1052,10 +1009,8 @@ mod tests { inlay_edits = Patch::new(edits); } 30..=59 => { - for (new_fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) { - fold_snapshot = new_fold_snapshot; - let (_, edits) = suggestion_map.sync(fold_snapshot.clone(), fold_edits); - suggestion_edits = suggestion_edits.compose(edits); + for (_, edits) in fold_map.randomly_mutate(&mut rng) { + fold_edits = fold_edits.compose(edits); } } _ => buffer.update(cx, |buffer, cx| { @@ -1069,21 +1024,17 @@ mod tests { }), }; - let (new_fold_snapshot, fold_edits) = + let (new_fold_snapshot, new_fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits); fold_snapshot = new_fold_snapshot; - let (new_suggestion_snapshot, new_suggestion_edits) = - suggestion_map.sync(fold_snapshot.clone(), fold_edits); - suggestion_snapshot = new_suggestion_snapshot; - suggestion_edits = suggestion_edits.compose(new_suggestion_edits); + fold_edits = fold_edits.compose(new_fold_edits); let (new_inlay_snapshot, new_inlay_edits) = - inlay_map.sync(suggestion_snapshot.clone(), suggestion_edits.into_inner()); + inlay_map.sync(fold_snapshot.clone(), fold_edits.into_inner()); inlay_snapshot = new_inlay_snapshot; inlay_edits = inlay_edits.compose(new_inlay_edits); log::info!("buffer text: {:?}", buffer_snapshot.text()); log::info!("folds text: {:?}", fold_snapshot.text()); - log::info!("suggestions text: {:?}", suggestion_snapshot.text()); log::info!("inlay text: {:?}", inlay_snapshot.text()); let inlays = inlay_map @@ -1093,12 +1044,11 @@ mod tests { .map(|inlay| { let buffer_point = inlay.position.to_point(&buffer_snapshot); let fold_point = fold_snapshot.to_fold_point(buffer_point, Bias::Left); - let suggestion_point = suggestion_snapshot.to_suggestion_point(fold_point); - let suggestion_offset = suggestion_snapshot.to_offset(suggestion_point); - (suggestion_offset, inlay.clone()) + let fold_offset = fold_point.to_offset(&fold_snapshot); + (fold_offset, inlay.clone()) }) .collect::>(); - let mut expected_text = Rope::from(suggestion_snapshot.text().as_str()); + let mut expected_text = Rope::from(fold_snapshot.text().as_str()); for (offset, inlay) in inlays.into_iter().rev() { expected_text.replace(offset.0..offset.0, &inlay.text.to_string()); } @@ -1172,11 +1122,11 @@ mod tests { inlay_offset ); assert_eq!( - inlay_snapshot.to_inlay_point(inlay_snapshot.to_suggestion_point(inlay_point)), + inlay_snapshot.to_inlay_point(inlay_snapshot.to_fold_point(inlay_point)), inlay_snapshot.clip_point(inlay_point, Bias::Left), - "to_suggestion_point({:?}) = {:?}", + "to_fold_point({:?}) = {:?}", inlay_point, - inlay_snapshot.to_suggestion_point(inlay_point), + inlay_snapshot.to_fold_point(inlay_point), ); let mut bytes = [0; 4]; diff --git a/crates/editor/src/display_map/tab_map.rs b/crates/editor/src/display_map/tab_map.rs index 5c2f05d67c..0deb0f888f 100644 --- a/crates/editor/src/display_map/tab_map.rs +++ b/crates/editor/src/display_map/tab_map.rs @@ -316,27 +316,15 @@ impl TabSnapshot { } pub fn make_tab_point(&self, point: Point, bias: Bias) -> TabPoint { - let fold_point = self - .inlay_snapshot - .suggestion_snapshot - .fold_snapshot - .to_fold_point(point, bias); - let suggestion_point = self - .inlay_snapshot - .suggestion_snapshot - .to_suggestion_point(fold_point); - let inlay_point = self.inlay_snapshot.to_inlay_point(suggestion_point); + let fold_point = self.inlay_snapshot.fold_snapshot.to_fold_point(point, bias); + let inlay_point = self.inlay_snapshot.to_inlay_point(fold_point); self.to_tab_point(inlay_point) } pub fn to_point(&self, point: TabPoint, bias: Bias) -> Point { let inlay_point = self.to_inlay_point(point, bias).0; - let suggestion_point = self.inlay_snapshot.to_suggestion_point(inlay_point); - let fold_point = self - .inlay_snapshot - .suggestion_snapshot - .to_fold_point(suggestion_point); - fold_point.to_buffer_point(&self.inlay_snapshot.suggestion_snapshot.fold_snapshot) + let fold_point = self.inlay_snapshot.to_fold_point(inlay_point); + fold_point.to_buffer_point(&self.inlay_snapshot.fold_snapshot) } fn expand_tabs(&self, chars: impl Iterator, column: u32) -> u32 { @@ -579,7 +567,7 @@ impl<'a> Iterator for TabChunks<'a> { mod tests { use super::*; use crate::{ - display_map::{fold_map::FoldMap, inlay_map::InlayMap, suggestion_map::SuggestionMap}, + display_map::{fold_map::FoldMap, inlay_map::InlayMap}, MultiBuffer, }; use rand::{prelude::StdRng, Rng}; @@ -589,8 +577,7 @@ mod tests { let buffer = MultiBuffer::build_simple("", cx); let buffer_snapshot = buffer.read(cx).snapshot(cx); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); - let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); - let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot); + let (_, inlay_snapshot) = InlayMap::new(fold_snapshot); let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); assert_eq!(tab_snapshot.expand_tabs("\t".chars(), 0), 0); @@ -607,8 +594,7 @@ mod tests { let buffer = MultiBuffer::build_simple(input, cx); let buffer_snapshot = buffer.read(cx).snapshot(cx); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); - let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); - let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot); + let (_, inlay_snapshot) = InlayMap::new(fold_snapshot); let (_, mut tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); tab_snapshot.max_expansion_column = max_expansion_column; @@ -656,8 +642,7 @@ mod tests { let buffer = MultiBuffer::build_simple(input, cx); let buffer_snapshot = buffer.read(cx).snapshot(cx); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); - let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); - let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot); + let (_, inlay_snapshot) = InlayMap::new(fold_snapshot); let (_, mut tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); tab_snapshot.max_expansion_column = max_expansion_column; @@ -671,8 +656,7 @@ mod tests { let buffer = MultiBuffer::build_simple(&input, cx); let buffer_snapshot = buffer.read(cx).snapshot(cx); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); - let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); - let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot); + let (_, inlay_snapshot) = InlayMap::new(fold_snapshot); let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); assert_eq!( @@ -734,10 +718,8 @@ mod tests { fold_map.randomly_mutate(&mut rng); let (fold_snapshot, _) = fold_map.read(buffer_snapshot, vec![]); log::info!("FoldMap text: {:?}", fold_snapshot.text()); - let (suggestion_map, _) = SuggestionMap::new(fold_snapshot); - let (suggestion_snapshot, _) = suggestion_map.randomly_mutate(&mut rng); - log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text()); - let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone()); + let (mut inlay_map, _) = InlayMap::new(fold_snapshot.clone()); + let (inlay_snapshot, _) = inlay_map.randomly_mutate(&mut 0, &mut rng); log::info!("InlayMap text: {:?}", inlay_snapshot.text()); let (tab_map, _) = TabMap::new(inlay_snapshot.clone(), tab_size); diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs index a18cc7da56..2e2fa449bd 100644 --- a/crates/editor/src/display_map/wrap_map.rs +++ b/crates/editor/src/display_map/wrap_map.rs @@ -763,25 +763,12 @@ impl WrapSnapshot { for display_row in 0..=self.max_point().row() { let tab_point = self.to_tab_point(WrapPoint::new(display_row, 0)); let inlay_point = self.tab_snapshot.to_inlay_point(tab_point, Bias::Left).0; - let suggestion_point = self - .tab_snapshot - .inlay_snapshot - .to_suggestion_point(inlay_point); - let fold_point = self - .tab_snapshot - .inlay_snapshot - .suggestion_snapshot - .to_fold_point(suggestion_point); + let fold_point = self.tab_snapshot.inlay_snapshot.to_fold_point(inlay_point); if fold_point.row() == prev_fold_row && display_row != 0 { expected_buffer_rows.push(None); } else { - let buffer_point = fold_point.to_buffer_point( - &self - .tab_snapshot - .inlay_snapshot - .suggestion_snapshot - .fold_snapshot, - ); + let buffer_point = + fold_point.to_buffer_point(&self.tab_snapshot.inlay_snapshot.fold_snapshot); expected_buffer_rows.push(input_buffer_rows[buffer_point.row as usize]); prev_fold_row = fold_point.row(); } @@ -1045,9 +1032,7 @@ fn consolidate_wrap_edits(edits: &mut Vec) { mod tests { use super::*; use crate::{ - display_map::{ - fold_map::FoldMap, inlay_map::InlayMap, suggestion_map::SuggestionMap, tab_map::TabMap, - }, + display_map::{fold_map::FoldMap, inlay_map::InlayMap, tab_map::TabMap}, MultiBuffer, }; use gpui::test::observe; @@ -1100,9 +1085,7 @@ mod tests { log::info!("Buffer text: {:?}", buffer_snapshot.text()); let (mut fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); log::info!("FoldMap text: {:?}", fold_snapshot.text()); - let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone()); - log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text()); - let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone()); + let (mut inlay_map, inlay_snapshot) = InlayMap::new(fold_snapshot.clone()); log::info!("InlaysMap text: {:?}", inlay_snapshot.text()); let (tab_map, _) = TabMap::new(inlay_snapshot.clone(), tab_size); let tabs_snapshot = tab_map.set_max_expansion_column(32); @@ -1133,6 +1116,7 @@ mod tests { ); log::info!("Wrapped text: {:?}", actual_text); + let mut next_inlay_id = 0; let mut edits = Vec::new(); for _i in 0..operations { log::info!("{} ==============================================", _i); @@ -1150,10 +1134,8 @@ mod tests { } 20..=39 => { for (fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) { - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot, fold_edits); let (inlay_snapshot, inlay_edits) = - inlay_map.sync(suggestion_snapshot, suggestion_edits); + inlay_map.sync(fold_snapshot, fold_edits); let (tabs_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size); let (mut snapshot, wrap_edits) = @@ -1164,10 +1146,8 @@ mod tests { } } 40..=59 => { - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.randomly_mutate(&mut rng); let (inlay_snapshot, inlay_edits) = - inlay_map.sync(suggestion_snapshot, suggestion_edits); + inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng); let (tabs_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size); let (mut snapshot, wrap_edits) = @@ -1190,11 +1170,8 @@ mod tests { log::info!("Buffer text: {:?}", buffer_snapshot.text()); let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits); log::info!("FoldMap text: {:?}", fold_snapshot.text()); - let (suggestion_snapshot, suggestion_edits) = - suggestion_map.sync(fold_snapshot, fold_edits); - log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text()); - let (inlay_snapshot, inlay_edits) = - inlay_map.sync(suggestion_snapshot, suggestion_edits); + let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits); + log::info!("InlayMap text: {:?}", inlay_snapshot.text()); let (tabs_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size); log::info!("TabMap text: {:?}", tabs_snapshot.text());