Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove the SuggestionMap

Browse source 
Co-Authored-By: Antonio Scandurra <antonio@zed.dev>
This commit is contained in:
Kirill Bulatov 2023-06-15 11:50:01 +03:00
parent 8cdf1a0faf
commit d2fef07782
6 changed files with 201 additions and 308 deletions
Download patch file Download diff file Expand all files Collapse all files

29
crates/editor/src/display_map.rs
View file

@ -1,12 +1,11 @@
mod block_map; mod block_map;
mod fold_map; mod fold_map;
mod inlay_map; mod inlay_map;
mod suggestion_map;
mod tab_map; mod tab_map;
mod wrap_map; mod wrap_map;
use crate::{ use crate::{
inlay_cache::{Inlay, InlayId, InlayProperties}, inlay_cache::{InlayId, InlayProperties},
Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint, Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint,
}; };
pub use block_map::{BlockMap, BlockPoint}; pub use block_map::{BlockMap, BlockPoint};
@ -22,8 +21,6 @@ use language::{
language_settings::language_settings, OffsetUtf16, Point, Subscription as BufferSubscription, language_settings::language_settings, OffsetUtf16, Point, Subscription as BufferSubscription,
}; };
use std::{any::TypeId, fmt::Debug, num::NonZeroU32, ops::Range, sync::Arc}; 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 sum_tree::{Bias, TreeMap};
use tab_map::TabMap; use tab_map::TabMap;
use text::Rope; use text::Rope;
@ -50,7 +47,6 @@ pub struct DisplayMap {
buffer: ModelHandle<MultiBuffer>, buffer: ModelHandle<MultiBuffer>,
buffer_subscription: BufferSubscription, buffer_subscription: BufferSubscription,
fold_map: FoldMap, fold_map: FoldMap,
suggestion_map: SuggestionMap,
inlay_map: InlayMap, inlay_map: InlayMap,
tab_map: TabMap, tab_map: TabMap,
wrap_map: ModelHandle<WrapMap>, wrap_map: ModelHandle<WrapMap>,
@ -77,7 +73,6 @@ impl DisplayMap {
let tab_size = Self::tab_size(&buffer, cx); let tab_size = Self::tab_size(&buffer, cx);
let (fold_map, snapshot) = FoldMap::new(buffer.read(cx).snapshot(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 (inlay_map, snapshot) = InlayMap::new(snapshot);
let (tab_map, snapshot) = TabMap::new(snapshot, tab_size); let (tab_map, snapshot) = TabMap::new(snapshot, tab_size);
let (wrap_map, snapshot) = WrapMap::new(snapshot, font_id, font_size, wrap_width, cx); let (wrap_map, snapshot) = WrapMap::new(snapshot, font_id, font_size, wrap_width, cx);
@ -87,7 +82,6 @@ impl DisplayMap {
buffer, buffer,
buffer_subscription, buffer_subscription,
fold_map, fold_map,
suggestion_map,
inlay_map, inlay_map,
tab_map, tab_map,
wrap_map, wrap_map,
@ -101,8 +95,7 @@ impl DisplayMap {
let buffer_snapshot = self.buffer.read(cx).snapshot(cx); let buffer_snapshot = self.buffer.read(cx).snapshot(cx);
let edits = self.buffer_subscription.consume().into_inner(); let edits = self.buffer_subscription.consume().into_inner();
let (fold_snapshot, edits) = self.fold_map.read(buffer_snapshot, edits); 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(fold_snapshot.clone(), edits);
let (inlay_snapshot, edits) = self.inlay_map.sync(suggestion_snapshot.clone(), edits);
let tab_size = Self::tab_size(&self.buffer, cx); let tab_size = Self::tab_size(&self.buffer, cx);
let (tab_snapshot, edits) = self.tab_map.sync(inlay_snapshot.clone(), edits, tab_size); let (tab_snapshot, edits) = self.tab_map.sync(inlay_snapshot.clone(), edits, tab_size);
let (wrap_snapshot, edits) = self let (wrap_snapshot, edits) = self
@ -113,7 +106,6 @@ impl DisplayMap {
DisplaySnapshot { DisplaySnapshot {
buffer_snapshot: self.buffer.read(cx).snapshot(cx), buffer_snapshot: self.buffer.read(cx).snapshot(cx),
fold_snapshot, fold_snapshot,
suggestion_snapshot,
inlay_snapshot, inlay_snapshot,
tab_snapshot, tab_snapshot,
wrap_snapshot, wrap_snapshot,
@ -141,7 +133,6 @@ impl DisplayMap {
let edits = self.buffer_subscription.consume().into_inner(); let edits = self.buffer_subscription.consume().into_inner();
let tab_size = Self::tab_size(&self.buffer, cx); let tab_size = Self::tab_size(&self.buffer, cx);
let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits); 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.inlay_map.sync(snapshot, edits);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
let (snapshot, edits) = self let (snapshot, edits) = self
@ -149,7 +140,6 @@ impl DisplayMap {
.update(cx, |map, cx| map.sync(snapshot, edits, cx)); .update(cx, |map, cx| map.sync(snapshot, edits, cx));
self.block_map.read(snapshot, edits); self.block_map.read(snapshot, edits);
let (snapshot, edits) = fold_map.fold(ranges); 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.inlay_map.sync(snapshot, edits);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
let (snapshot, edits) = self let (snapshot, edits) = self
@ -168,7 +158,6 @@ impl DisplayMap {
let edits = self.buffer_subscription.consume().into_inner(); let edits = self.buffer_subscription.consume().into_inner();
let tab_size = Self::tab_size(&self.buffer, cx); let tab_size = Self::tab_size(&self.buffer, cx);
let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits); 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.inlay_map.sync(snapshot, edits);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
let (snapshot, edits) = self let (snapshot, edits) = self
@ -176,7 +165,6 @@ impl DisplayMap {
.update(cx, |map, cx| map.sync(snapshot, edits, cx)); .update(cx, |map, cx| map.sync(snapshot, edits, cx));
self.block_map.read(snapshot, edits); self.block_map.read(snapshot, edits);
let (snapshot, edits) = fold_map.unfold(ranges, inclusive); 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.inlay_map.sync(snapshot, edits);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
let (snapshot, edits) = self let (snapshot, edits) = self
@ -194,7 +182,6 @@ impl DisplayMap {
let edits = self.buffer_subscription.consume().into_inner(); let edits = self.buffer_subscription.consume().into_inner();
let tab_size = Self::tab_size(&self.buffer, cx); let tab_size = Self::tab_size(&self.buffer, cx);
let (snapshot, edits) = self.fold_map.read(snapshot, edits); 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.inlay_map.sync(snapshot, edits);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
let (snapshot, edits) = self let (snapshot, edits) = self
@ -213,7 +200,6 @@ impl DisplayMap {
let edits = self.buffer_subscription.consume().into_inner(); let edits = self.buffer_subscription.consume().into_inner();
let tab_size = Self::tab_size(&self.buffer, cx); let tab_size = Self::tab_size(&self.buffer, cx);
let (snapshot, edits) = self.fold_map.read(snapshot, edits); 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.inlay_map.sync(snapshot, edits);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
let (snapshot, edits) = self let (snapshot, edits) = self
@ -269,7 +255,6 @@ impl DisplayMap {
let edits = self.buffer_subscription.consume().into_inner(); let edits = self.buffer_subscription.consume().into_inner();
let tab_size = Self::tab_size(&self.buffer, cx); let tab_size = Self::tab_size(&self.buffer, cx);
let (snapshot, edits) = self.fold_map.read(buffer_snapshot.clone(), edits); 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.inlay_map.sync(snapshot, edits);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size); let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
let (snapshot, edits) = self let (snapshot, edits) = self
@ -302,7 +287,6 @@ impl DisplayMap {
pub struct DisplaySnapshot { pub struct DisplaySnapshot {
pub buffer_snapshot: MultiBufferSnapshot, pub buffer_snapshot: MultiBufferSnapshot,
fold_snapshot: fold_map::FoldSnapshot, fold_snapshot: fold_map::FoldSnapshot,
suggestion_snapshot: suggestion_map::SuggestionSnapshot,
inlay_snapshot: inlay_map::InlaySnapshot, inlay_snapshot: inlay_map::InlaySnapshot,
tab_snapshot: tab_map::TabSnapshot, tab_snapshot: tab_map::TabSnapshot,
wrap_snapshot: wrap_map::WrapSnapshot, wrap_snapshot: wrap_map::WrapSnapshot,
@ -380,8 +364,7 @@ impl DisplaySnapshot {
fn point_to_display_point(&self, point: Point, bias: Bias) -> DisplayPoint { fn point_to_display_point(&self, point: Point, bias: Bias) -> DisplayPoint {
let fold_point = self.fold_snapshot.to_fold_point(point, bias); 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(fold_point);
let inlay_point = self.inlay_snapshot.to_inlay_point(suggestion_point);
let tab_point = self.tab_snapshot.to_tab_point(inlay_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 wrap_point = self.wrap_snapshot.tab_point_to_wrap_point(tab_point);
let block_point = self.block_snapshot.to_block_point(wrap_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 wrap_point = self.block_snapshot.to_wrap_point(block_point);
let tab_point = self.wrap_snapshot.to_tab_point(wrap_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 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.inlay_snapshot.to_fold_point(inlay_point);
let fold_point = self.suggestion_snapshot.to_fold_point(suggestion_point);
fold_point.to_buffer_point(&self.fold_snapshot) 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 wrap_point = map.block_snapshot.to_wrap_point(self.0);
let tab_point = map.wrap_snapshot.to_tab_point(wrap_point); 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 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.inlay_snapshot.to_fold_point(inlay_point);
let fold_point = map.suggestion_snapshot.to_fold_point(suggestion_point);
fold_point.to_buffer_offset(&map.fold_snapshot) fold_point.to_buffer_offset(&map.fold_snapshot)
} }
} }

29
crates/editor/src/display_map/block_map.rs
View file

@ -990,7 +990,6 @@ fn offset_for_row(s: &str, target: u32) -> (u32, usize) {
mod tests { mod tests {
use super::*; use super::*;
use crate::display_map::inlay_map::InlayMap; 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::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap};
use crate::multi_buffer::MultiBuffer; use crate::multi_buffer::MultiBuffer;
use gpui::{elements::Empty, Element}; use gpui::{elements::Empty, Element};
@ -1032,8 +1031,7 @@ mod tests {
let buffer_snapshot = buffer.read(cx).snapshot(cx); let buffer_snapshot = buffer.read(cx).snapshot(cx);
let subscription = buffer.update(cx, |buffer, _| buffer.subscribe()); let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
let (fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); 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(fold_snapshot);
let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (tab_map, tab_snapshot) = TabMap::new(inlay_snapshot, 1.try_into().unwrap()); 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 (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); let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
@ -1179,9 +1177,7 @@ mod tests {
let (fold_snapshot, fold_edits) = let (fold_snapshot, fold_edits) =
fold_map.read(buffer_snapshot, subscription.consume().into_inner()); fold_map.read(buffer_snapshot, subscription.consume().into_inner());
let (suggestion_snapshot, suggestion_edits) = let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits);
suggestion_map.sync(fold_snapshot, fold_edits);
let (inlay_snapshot, inlay_edits) = inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tab_snapshot, tab_edits) = let (tab_snapshot, tab_edits) =
tab_map.sync(inlay_snapshot, inlay_edits, 4.try_into().unwrap()); tab_map.sync(inlay_snapshot, inlay_edits, 4.try_into().unwrap());
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| { 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 = MultiBuffer::build_simple(text, cx);
let buffer_snapshot = buffer.read(cx).snapshot(cx); let buffer_snapshot = buffer.read(cx).snapshot(cx);
let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); let (_, inlay_snapshot) = InlayMap::new(fold_snapshot);
let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); 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 (_, wraps_snapshot) = WrapMap::new(tab_snapshot, font_id, 14.0, Some(60.), cx);
let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1); 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 mut buffer_snapshot = buffer.read(cx).snapshot(cx);
let (fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); 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(fold_snapshot);
let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (tab_map, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); let (tab_map, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap());
let (wrap_map, wraps_snapshot) = let (wrap_map, wraps_snapshot) =
WrapMap::new(tab_snapshot, font_id, font_size, wrap_width, cx); WrapMap::new(tab_snapshot, font_id, font_size, wrap_width, cx);
@ -1339,10 +1333,7 @@ mod tests {
let (fold_snapshot, fold_edits) = let (fold_snapshot, fold_edits) =
fold_map.read(buffer_snapshot.clone(), vec![]); fold_map.read(buffer_snapshot.clone(), vec![]);
let (suggestion_snapshot, suggestion_edits) = let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits);
suggestion_map.sync(fold_snapshot, fold_edits);
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tab_snapshot, tab_edits) = let (tab_snapshot, tab_edits) =
tab_map.sync(inlay_snapshot, inlay_edits, tab_size); tab_map.sync(inlay_snapshot, inlay_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| { let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
@ -1366,10 +1357,7 @@ mod tests {
let (fold_snapshot, fold_edits) = let (fold_snapshot, fold_edits) =
fold_map.read(buffer_snapshot.clone(), vec![]); fold_map.read(buffer_snapshot.clone(), vec![]);
let (suggestion_snapshot, suggestion_edits) = let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits);
suggestion_map.sync(fold_snapshot, fold_edits);
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tab_snapshot, tab_edits) = let (tab_snapshot, tab_edits) =
tab_map.sync(inlay_snapshot, inlay_edits, tab_size); tab_map.sync(inlay_snapshot, inlay_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| { 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 (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
let (suggestion_snapshot, suggestion_edits) = let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits);
suggestion_map.sync(fold_snapshot, fold_edits);
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tab_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size); 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| { let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx) wrap_map.sync(tab_snapshot, tab_edits, cx)

20
crates/editor/src/display_map/fold_map.rs
View file

@ -11,7 +11,7 @@ use std::{
any::TypeId, any::TypeId,
cmp::{self, Ordering}, cmp::{self, Ordering},
iter::{self, Peekable}, iter::{self, Peekable},
ops::{Range, Sub}, ops::{Add, AddAssign, Range, Sub},
sync::atomic::{AtomicUsize, Ordering::SeqCst}, sync::atomic::{AtomicUsize, Ordering::SeqCst},
vec, vec,
}; };
@ -508,6 +508,10 @@ impl FoldSnapshot {
self.folds.items(&self.buffer_snapshot).len() 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<FoldPoint>) -> TextSummary { pub fn text_summary_for_range(&self, range: Range<FoldPoint>) -> TextSummary {
let mut summary = TextSummary::default(); 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 { impl Sub for FoldOffset {
type Output = Self; type Output = Self;

348
crates/editor/src/display_map/inlay_map.rs
View file

@ -1,8 +1,5 @@
use super::{ use super::{
suggestion_map::{ fold_map::{FoldBufferRows, FoldChunks, FoldEdit, FoldOffset, FoldPoint, FoldSnapshot},
SuggestionBufferRows, SuggestionChunks, SuggestionEdit, SuggestionOffset, SuggestionPoint,
SuggestionSnapshot,
},
TextHighlights, TextHighlights,
}; };
use crate::{ use crate::{
@ -29,7 +26,7 @@ pub struct InlayMap {
#[derive(Clone)] #[derive(Clone)]
pub struct InlaySnapshot { pub struct InlaySnapshot {
// TODO kb merge these two together // TODO kb merge these two together
pub suggestion_snapshot: SuggestionSnapshot, pub fold_snapshot: FoldSnapshot,
transforms: SumTree<Transform>, transforms: SumTree<Transform>,
pub version: usize, 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, _: &()) { fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
self.0 += &summary.input.len; 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, _: &()) { fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
self.0 += &summary.input.lines; self.0 += &summary.input.lines;
} }
@ -128,15 +125,15 @@ impl<'a> sum_tree::Dimension<'a, TransformSummary> for SuggestionPoint {
#[derive(Clone)] #[derive(Clone)]
pub struct InlayBufferRows<'a> { pub struct InlayBufferRows<'a> {
transforms: Cursor<'a, Transform, (InlayPoint, SuggestionPoint)>, transforms: Cursor<'a, Transform, (InlayPoint, FoldPoint)>,
suggestion_rows: SuggestionBufferRows<'a>, fold_rows: FoldBufferRows<'a>,
inlay_row: u32, inlay_row: u32,
} }
pub struct InlayChunks<'a> { pub struct InlayChunks<'a> {
transforms: Cursor<'a, Transform, (InlayOffset, SuggestionOffset)>, transforms: Cursor<'a, Transform, (InlayOffset, FoldOffset)>,
suggestion_chunks: SuggestionChunks<'a>, fold_chunks: FoldChunks<'a>,
suggestion_chunk: Option<Chunk<'a>>, fold_chunk: Option<Chunk<'a>>,
inlay_chunks: Option<text::Chunks<'a>>, inlay_chunks: Option<text::Chunks<'a>>,
output_offset: InlayOffset, output_offset: InlayOffset,
max_output_offset: InlayOffset, max_output_offset: InlayOffset,
@ -154,10 +151,10 @@ impl<'a> Iterator for InlayChunks<'a> {
let chunk = match self.transforms.item()? { let chunk = match self.transforms.item()? {
Transform::Isomorphic(_) => { Transform::Isomorphic(_) => {
let chunk = self let chunk = self
.suggestion_chunk .fold_chunk
.get_or_insert_with(|| self.suggestion_chunks.next().unwrap()); .get_or_insert_with(|| self.fold_chunks.next().unwrap());
if chunk.text.is_empty() { 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( let (prefix, suffix) = chunk.text.split_at(cmp::min(
@ -204,11 +201,11 @@ impl<'a> Iterator for InlayBufferRows<'a> {
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
let buffer_row = if self.inlay_row == 0 { let buffer_row = if self.inlay_row == 0 {
self.suggestion_rows.next().unwrap() self.fold_rows.next().unwrap()
} else { } else {
match self.transforms.item()? { match self.transforms.item()? {
Transform::Inlay(_) => None, 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 { impl InlayMap {
pub fn new(suggestion_snapshot: SuggestionSnapshot) -> (Self, InlaySnapshot) { pub fn new(fold_snapshot: FoldSnapshot) -> (Self, InlaySnapshot) {
let snapshot = InlaySnapshot { let snapshot = InlaySnapshot {
suggestion_snapshot: suggestion_snapshot.clone(), fold_snapshot: fold_snapshot.clone(),
version: 0, version: 0,
transforms: SumTree::from_item( 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( pub fn sync(
&mut self, &mut self,
suggestion_snapshot: SuggestionSnapshot, fold_snapshot: FoldSnapshot,
mut suggestion_edits: Vec<SuggestionEdit>, mut fold_edits: Vec<FoldEdit>,
) -> (InlaySnapshot, Vec<InlayEdit>) { ) -> (InlaySnapshot, Vec<InlayEdit>) {
let mut snapshot = self.snapshot.lock(); let mut snapshot = self.snapshot.lock();
let mut new_snapshot = snapshot.clone(); 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; new_snapshot.version += 1;
} }
if suggestion_snapshot if fold_snapshot
.buffer_snapshot() .buffer_snapshot()
.trailing_excerpt_update_count() .trailing_excerpt_update_count()
!= snapshot != snapshot
.suggestion_snapshot .fold_snapshot
.buffer_snapshot() .buffer_snapshot()
.trailing_excerpt_update_count() .trailing_excerpt_update_count()
{ {
if suggestion_edits.is_empty() { if fold_edits.is_empty() {
suggestion_edits.push(Edit { fold_edits.push(Edit {
old: snapshot.suggestion_snapshot.len()..snapshot.suggestion_snapshot.len(), old: snapshot.fold_snapshot.len()..snapshot.fold_snapshot.len(),
new: suggestion_snapshot.len()..suggestion_snapshot.len(), new: fold_snapshot.len()..fold_snapshot.len(),
}); });
} }
} }
let mut inlay_edits = Patch::default(); let mut inlay_edits = Patch::default();
let mut new_transforms = SumTree::new(); let mut new_transforms = SumTree::new();
let mut cursor = snapshot let mut cursor = snapshot.transforms.cursor::<(FoldOffset, InlayOffset)>();
.transforms let mut fold_edits_iter = fold_edits.iter().peekable();
.cursor::<(SuggestionOffset, InlayOffset)>(); while let Some(fold_edit) = fold_edits_iter.next() {
let mut suggestion_edits_iter = suggestion_edits.iter().peekable(); new_transforms.push_tree(cursor.slice(&fold_edit.old.start, Bias::Left, &()), &());
while let Some(suggestion_edit) = suggestion_edits_iter.next() {
new_transforms.push_tree(
cursor.slice(&suggestion_edit.old.start, Bias::Left, &()),
&(),
);
if let Some(Transform::Isomorphic(transform)) = cursor.item() { 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()), &()); new_transforms.push(Transform::Isomorphic(transform.clone()), &());
cursor.next(&()); cursor.next(&());
} }
@ -303,30 +295,30 @@ impl InlayMap {
// Remove all the inlays and transforms contained by the edit. // Remove all the inlays and transforms contained by the edit.
let old_start = let old_start =
cursor.start().1 + InlayOffset(suggestion_edit.old.start.0 - cursor.start().0 .0); cursor.start().1 + InlayOffset(fold_edit.old.start.0 - cursor.start().0 .0);
cursor.seek(&suggestion_edit.old.end, Bias::Right, &()); cursor.seek(&fold_edit.old.end, Bias::Right, &());
let old_end = let old_end = cursor.start().1 + InlayOffset(fold_edit.old.end.0 - cursor.start().0 .0);
cursor.start().1 + InlayOffset(suggestion_edit.old.end.0 - cursor.start().0 .0);
// Push the unchanged prefix. // Push the unchanged prefix.
let prefix_start = SuggestionOffset(new_transforms.summary().input.len); let prefix_start = FoldOffset(new_transforms.summary().input.len);
let prefix_end = suggestion_edit.new.start; let prefix_end = fold_edit.new.start;
push_isomorphic( push_isomorphic(
&mut new_transforms, &mut new_transforms,
suggestion_snapshot.text_summary_for_range( fold_snapshot.text_summary_for_range(
suggestion_snapshot.to_point(prefix_start) prefix_start.to_point(&fold_snapshot)..prefix_end.to_point(&fold_snapshot),
..suggestion_snapshot.to_point(prefix_end),
), ),
); );
let new_start = InlayOffset(new_transforms.summary().output.len); let new_start = InlayOffset(new_transforms.summary().output.len);
let start_point = suggestion_snapshot let start_point = fold_edit
.to_fold_point(suggestion_snapshot.to_point(suggestion_edit.new.start)) .new
.to_buffer_point(&suggestion_snapshot.fold_snapshot); .start
.to_point(&fold_snapshot)
.to_buffer_point(&fold_snapshot);
let start_ix = match self.inlays.binary_search_by(|probe| { let start_ix = match self.inlays.binary_search_by(|probe| {
probe probe
.position .position
.to_point(&suggestion_snapshot.buffer_snapshot()) .to_point(&fold_snapshot.buffer_snapshot())
.cmp(&start_point) .cmp(&start_point)
.then(std::cmp::Ordering::Greater) .then(std::cmp::Ordering::Greater)
}) { }) {
@ -334,43 +326,34 @@ impl InlayMap {
}; };
for inlay in &self.inlays[start_ix..] { for inlay in &self.inlays[start_ix..] {
let buffer_point = inlay let buffer_point = inlay.position.to_point(fold_snapshot.buffer_snapshot());
.position let fold_point = fold_snapshot.to_fold_point(buffer_point, Bias::Left);
.to_point(suggestion_snapshot.buffer_snapshot()); let fold_offset = fold_point.to_offset(&fold_snapshot);
let fold_point = suggestion_snapshot if fold_offset > fold_edit.new.end {
.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 {
break; break;
} }
let prefix_start = SuggestionOffset(new_transforms.summary().input.len); let prefix_start = FoldOffset(new_transforms.summary().input.len);
let prefix_end = suggestion_offset; let prefix_end = fold_offset;
push_isomorphic( push_isomorphic(
&mut new_transforms, &mut new_transforms,
suggestion_snapshot.text_summary_for_range( fold_snapshot.text_summary_for_range(
suggestion_snapshot.to_point(prefix_start) prefix_start.to_point(&fold_snapshot)..prefix_end.to_point(&fold_snapshot),
..suggestion_snapshot.to_point(prefix_end),
), ),
); );
if inlay if inlay.position.is_valid(fold_snapshot.buffer_snapshot()) {
.position
.is_valid(suggestion_snapshot.buffer_snapshot())
{
new_transforms.push(Transform::Inlay(inlay.clone()), &()); new_transforms.push(Transform::Inlay(inlay.clone()), &());
} }
} }
// Apply the rest of the edit. // 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( push_isomorphic(
&mut new_transforms, &mut new_transforms,
suggestion_snapshot.text_summary_for_range( fold_snapshot.text_summary_for_range(
suggestion_snapshot.to_point(transform_start) transform_start.to_point(&fold_snapshot)
..suggestion_snapshot.to_point(suggestion_edit.new.end), ..fold_edit.new.end.to_point(&fold_snapshot),
), ),
); );
let new_end = InlayOffset(new_transforms.summary().output.len); 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 // If the next edit doesn't intersect the current isomorphic transform, then
// we can push its remainder. // we can push its remainder.
if suggestion_edits_iter if fold_edits_iter
.peek() .peek()
.map_or(true, |edit| edit.old.start >= cursor.end(&()).0) .map_or(true, |edit| edit.old.start >= cursor.end(&()).0)
{ {
let transform_start = SuggestionOffset(new_transforms.summary().input.len); let transform_start = FoldOffset(new_transforms.summary().input.len);
let transform_end = let transform_end = fold_edit.new.end + (cursor.end(&()).0 - fold_edit.old.end);
suggestion_edit.new.end + (cursor.end(&()).0 - suggestion_edit.old.end);
push_isomorphic( push_isomorphic(
&mut new_transforms, &mut new_transforms,
suggestion_snapshot.text_summary_for_range( fold_snapshot.text_summary_for_range(
suggestion_snapshot.to_point(transform_start) transform_start.to_point(&fold_snapshot)
..suggestion_snapshot.to_point(transform_end), ..transform_end.to_point(&fold_snapshot),
), ),
); );
cursor.next(&()); cursor.next(&());
@ -404,7 +386,7 @@ impl InlayMap {
new_transforms.push(Transform::Isomorphic(Default::default()), &()); new_transforms.push(Transform::Isomorphic(Default::default()), &());
} }
new_snapshot.transforms = new_transforms; new_snapshot.transforms = new_transforms;
new_snapshot.suggestion_snapshot = suggestion_snapshot; new_snapshot.fold_snapshot = fold_snapshot;
new_snapshot.check_invariants(); new_snapshot.check_invariants();
drop(cursor); drop(cursor);
@ -427,12 +409,10 @@ impl InlayMap {
if let Some(inlay) = self.inlays_by_id.remove(&inlay_id) { if let Some(inlay) = self.inlays_by_id.remove(&inlay_id) {
let buffer_point = inlay.position.to_point(snapshot.buffer_snapshot()); let buffer_point = inlay.position.to_point(snapshot.buffer_snapshot());
let fold_point = snapshot let fold_point = snapshot
.suggestion_snapshot
.fold_snapshot .fold_snapshot
.to_fold_point(buffer_point, Bias::Left); .to_fold_point(buffer_point, Bias::Left);
let suggestion_point = snapshot.suggestion_snapshot.to_suggestion_point(fold_point); let fold_offset = fold_point.to_offset(&snapshot.fold_snapshot);
let suggestion_offset = snapshot.suggestion_snapshot.to_offset(suggestion_point); edits.insert(fold_offset);
edits.insert(suggestion_offset);
} }
} }
@ -455,16 +435,14 @@ impl InlayMap {
let buffer_point = inlay.position.to_point(snapshot.buffer_snapshot()); let buffer_point = inlay.position.to_point(snapshot.buffer_snapshot());
let fold_point = snapshot let fold_point = snapshot
.suggestion_snapshot
.fold_snapshot .fold_snapshot
.to_fold_point(buffer_point, Bias::Left); .to_fold_point(buffer_point, Bias::Left);
let suggestion_point = snapshot.suggestion_snapshot.to_suggestion_point(fold_point); let fold_offset = fold_point.to_offset(&snapshot.fold_snapshot);
let suggestion_offset = snapshot.suggestion_snapshot.to_offset(suggestion_point); edits.insert(fold_offset);
edits.insert(suggestion_offset);
} }
let suggestion_snapshot = snapshot.suggestion_snapshot.clone(); let fold_snapshot = snapshot.fold_snapshot.clone();
let suggestion_edits = edits let fold_edits = edits
.into_iter() .into_iter()
.map(|offset| Edit { .map(|offset| Edit {
old: offset..offset, old: offset..offset,
@ -472,11 +450,11 @@ impl InlayMap {
}) })
.collect(); .collect();
drop(snapshot); drop(snapshot);
self.sync(suggestion_snapshot, suggestion_edits) self.sync(fold_snapshot, fold_edits)
} }
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
pub fn randomly_mutate( pub(crate) fn randomly_mutate(
&mut self, &mut self,
next_inlay_id: &mut usize, next_inlay_id: &mut usize,
rng: &mut rand::rngs::StdRng, rng: &mut rand::rngs::StdRng,
@ -522,22 +500,22 @@ impl InlayMap {
impl InlaySnapshot { impl InlaySnapshot {
pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot { pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot {
self.suggestion_snapshot.buffer_snapshot() self.fold_snapshot.buffer_snapshot()
} }
pub fn to_point(&self, offset: InlayOffset) -> InlayPoint { pub fn to_point(&self, offset: InlayOffset) -> InlayPoint {
let mut cursor = self let mut cursor = self
.transforms .transforms
.cursor::<(InlayOffset, (InlayPoint, SuggestionOffset))>(); .cursor::<(InlayOffset, (InlayPoint, FoldOffset))>();
cursor.seek(&offset, Bias::Right, &()); cursor.seek(&offset, Bias::Right, &());
let overshoot = offset.0 - cursor.start().0 .0; let overshoot = offset.0 - cursor.start().0 .0;
match cursor.item() { match cursor.item() {
Some(Transform::Isomorphic(_)) => { Some(Transform::Isomorphic(_)) => {
let suggestion_offset_start = cursor.start().1 .1; let fold_offset_start = cursor.start().1 .1;
let suggestion_offset_end = SuggestionOffset(suggestion_offset_start.0 + overshoot); let fold_offset_end = FoldOffset(fold_offset_start.0 + overshoot);
let suggestion_start = self.suggestion_snapshot.to_point(suggestion_offset_start); let fold_start = fold_offset_start.to_point(&self.fold_snapshot);
let suggestion_end = self.suggestion_snapshot.to_point(suggestion_offset_end); let fold_end = fold_offset_end.to_point(&self.fold_snapshot);
InlayPoint(cursor.start().1 .0 .0 + (suggestion_end.0 - suggestion_start.0)) InlayPoint(cursor.start().1 .0 .0 + (fold_end.0 - fold_start.0))
} }
Some(Transform::Inlay(inlay)) => { Some(Transform::Inlay(inlay)) => {
let overshoot = inlay.text.offset_to_point(overshoot); let overshoot = inlay.text.offset_to_point(overshoot);
@ -558,16 +536,16 @@ impl InlaySnapshot {
pub fn to_offset(&self, point: InlayPoint) -> InlayOffset { pub fn to_offset(&self, point: InlayPoint) -> InlayOffset {
let mut cursor = self let mut cursor = self
.transforms .transforms
.cursor::<(InlayPoint, (InlayOffset, SuggestionPoint))>(); .cursor::<(InlayPoint, (InlayOffset, FoldPoint))>();
cursor.seek(&point, Bias::Right, &()); cursor.seek(&point, Bias::Right, &());
let overshoot = point.0 - cursor.start().0 .0; let overshoot = point.0 - cursor.start().0 .0;
match cursor.item() { match cursor.item() {
Some(Transform::Isomorphic(_)) => { Some(Transform::Isomorphic(_)) => {
let suggestion_point_start = cursor.start().1 .1; let fold_point_start = cursor.start().1 .1;
let suggestion_point_end = SuggestionPoint(suggestion_point_start.0 + overshoot); let fold_point_end = FoldPoint(fold_point_start.0 + overshoot);
let suggestion_start = self.suggestion_snapshot.to_offset(suggestion_point_start); let fold_start = fold_point_start.to_offset(&self.fold_snapshot);
let suggestion_end = self.suggestion_snapshot.to_offset(suggestion_point_end); let fold_end = fold_point_end.to_offset(&self.fold_snapshot);
InlayOffset(cursor.start().1 .0 .0 + (suggestion_end.0 - suggestion_start.0)) InlayOffset(cursor.start().1 .0 .0 + (fold_end.0 - fold_start.0))
} }
Some(Transform::Inlay(inlay)) => { Some(Transform::Inlay(inlay)) => {
let overshoot = inlay.text.point_to_offset(overshoot); let overshoot = inlay.text.point_to_offset(overshoot);
@ -582,34 +560,34 @@ impl InlaySnapshot {
.flat_map(|chunk| chunk.text.chars()) .flat_map(|chunk| chunk.text.chars())
} }
pub fn to_suggestion_point(&self, point: InlayPoint) -> SuggestionPoint { pub fn to_fold_point(&self, point: InlayPoint) -> FoldPoint {
let mut cursor = self.transforms.cursor::<(InlayPoint, SuggestionPoint)>(); let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>();
cursor.seek(&point, Bias::Right, &()); cursor.seek(&point, Bias::Right, &());
match cursor.item() { match cursor.item() {
Some(Transform::Isomorphic(_)) => { Some(Transform::Isomorphic(_)) => {
let overshoot = point.0 - cursor.start().0 .0; 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, 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 { pub fn to_fold_offset(&self, offset: InlayOffset) -> FoldOffset {
let mut cursor = self.transforms.cursor::<(InlayOffset, SuggestionOffset)>(); let mut cursor = self.transforms.cursor::<(InlayOffset, FoldOffset)>();
cursor.seek(&offset, Bias::Right, &()); cursor.seek(&offset, Bias::Right, &());
match cursor.item() { match cursor.item() {
Some(Transform::Isomorphic(_)) => { Some(Transform::Isomorphic(_)) => {
let overshoot = offset - cursor.start().0; let overshoot = offset - cursor.start().0;
cursor.start().1 + SuggestionOffset(overshoot.0) cursor.start().1 + FoldOffset(overshoot.0)
} }
Some(Transform::Inlay(_)) => cursor.start().1, 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 { pub fn to_inlay_point(&self, point: FoldPoint) -> InlayPoint {
let mut cursor = self.transforms.cursor::<(SuggestionPoint, InlayPoint)>(); let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>();
cursor.seek(&point, Bias::Left, &()); cursor.seek(&point, Bias::Left, &());
match cursor.item() { match cursor.item() {
Some(Transform::Isomorphic(_)) => { Some(Transform::Isomorphic(_)) => {
@ -622,7 +600,7 @@ impl InlaySnapshot {
} }
pub fn clip_point(&self, point: InlayPoint, bias: Bias) -> InlayPoint { 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, &()); cursor.seek(&point, Bias::Left, &());
let mut bias = bias; let mut bias = bias;
@ -644,10 +622,9 @@ impl InlaySnapshot {
} else { } else {
point.0 - cursor.start().0 .0 point.0 - cursor.start().0 .0
}; };
let suggestion_point = SuggestionPoint(cursor.start().1 .0 + overshoot); let fold_point = FoldPoint(cursor.start().1 .0 + overshoot);
let clipped_suggestion_point = let clipped_fold_point = self.fold_snapshot.clip_point(fold_point, bias);
self.suggestion_snapshot.clip_point(suggestion_point, bias); let clipped_overshoot = clipped_fold_point.0 - cursor.start().1 .0;
let clipped_overshoot = clipped_suggestion_point.0 - cursor.start().1 .0;
return InlayPoint(cursor.start().0 .0 + clipped_overshoot); return InlayPoint(cursor.start().0 .0 + clipped_overshoot);
} }
Some(Transform::Inlay(_)) => skipped_inlay = true, Some(Transform::Inlay(_)) => skipped_inlay = true,
@ -668,20 +645,19 @@ impl InlaySnapshot {
pub fn text_summary_for_range(&self, range: Range<InlayPoint>) -> TextSummary { pub fn text_summary_for_range(&self, range: Range<InlayPoint>) -> TextSummary {
let mut summary = TextSummary::default(); 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, &()); cursor.seek(&range.start, Bias::Right, &());
let overshoot = range.start.0 - cursor.start().0 .0; let overshoot = range.start.0 - cursor.start().0 .0;
match cursor.item() { match cursor.item() {
Some(Transform::Isomorphic(_)) => { Some(Transform::Isomorphic(_)) => {
let suggestion_start = cursor.start().1 .0; let fold_start = cursor.start().1 .0;
let suffix_start = SuggestionPoint(suggestion_start + overshoot); let suffix_start = FoldPoint(fold_start + overshoot);
let suffix_end = SuggestionPoint( let suffix_end = FoldPoint(
suggestion_start fold_start + (cmp::min(cursor.end(&()).0, range.end).0 - cursor.start().0 .0),
+ (cmp::min(cursor.end(&()).0, range.end).0 - cursor.start().0 .0),
); );
summary = self summary = self
.suggestion_snapshot .fold_snapshot
.text_summary_for_range(suffix_start..suffix_end); .text_summary_for_range(suffix_start..suffix_end);
cursor.next(&()); cursor.next(&());
} }
@ -705,9 +681,9 @@ impl InlaySnapshot {
match cursor.item() { match cursor.item() {
Some(Transform::Isomorphic(_)) => { Some(Transform::Isomorphic(_)) => {
let prefix_start = cursor.start().1; let prefix_start = cursor.start().1;
let prefix_end = SuggestionPoint(prefix_start.0 + overshoot); let prefix_end = FoldPoint(prefix_start.0 + overshoot);
summary += self summary += self
.suggestion_snapshot .fold_snapshot
.text_summary_for_range(prefix_start..prefix_end); .text_summary_for_range(prefix_start..prefix_end);
} }
Some(Transform::Inlay(inlay)) => { Some(Transform::Inlay(inlay)) => {
@ -722,30 +698,27 @@ impl InlaySnapshot {
} }
pub fn buffer_rows<'a>(&'a self, row: u32) -> InlayBufferRows<'a> { 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); let inlay_point = InlayPoint::new(row, 0);
cursor.seek(&inlay_point, Bias::Left, &()); cursor.seek(&inlay_point, Bias::Left, &());
let mut suggestion_point = cursor.start().1; let mut fold_point = cursor.start().1;
let suggestion_row = if row == 0 { let fold_row = if row == 0 {
0 0
} else { } else {
match cursor.item() { match cursor.item() {
Some(Transform::Isomorphic(_)) => { Some(Transform::Isomorphic(_)) => {
suggestion_point.0 += inlay_point.0 - cursor.start().0 .0; fold_point.0 += inlay_point.0 - cursor.start().0 .0;
suggestion_point.row() fold_point.row()
} }
_ => cmp::min( _ => cmp::min(fold_point.row() + 1, self.fold_snapshot.max_point().row()),
suggestion_point.row() + 1,
self.suggestion_snapshot.max_point().row(),
),
} }
}; };
InlayBufferRows { InlayBufferRows {
transforms: cursor, transforms: cursor,
inlay_row: inlay_point.row(), 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<InlayOffset>, range: Range<InlayOffset>,
language_aware: bool, language_aware: bool,
text_highlights: Option<&'a TextHighlights>, text_highlights: Option<&'a TextHighlights>,
suggestion_highlight: Option<HighlightStyle>, inlay_highlight_style: Option<HighlightStyle>,
) -> InlayChunks<'a> { ) -> InlayChunks<'a> {
let mut cursor = self.transforms.cursor::<(InlayOffset, SuggestionOffset)>(); let mut cursor = self.transforms.cursor::<(InlayOffset, FoldOffset)>();
cursor.seek(&range.start, Bias::Right, &()); cursor.seek(&range.start, Bias::Right, &());
let suggestion_range = let fold_range = self.to_fold_offset(range.start)..self.to_fold_offset(range.end);
self.to_suggestion_offset(range.start)..self.to_suggestion_offset(range.end); let fold_chunks = self
let suggestion_chunks = self.suggestion_snapshot.chunks( .fold_snapshot
suggestion_range, .chunks(fold_range, language_aware, text_highlights);
language_aware,
text_highlights,
suggestion_highlight,
);
InlayChunks { InlayChunks {
transforms: cursor, transforms: cursor,
suggestion_chunks, fold_chunks,
inlay_chunks: None, inlay_chunks: None,
suggestion_chunk: None, fold_chunk: None,
output_offset: range.start, output_offset: range.start,
max_output_offset: range.end, max_output_offset: range.end,
highlight_style: suggestion_highlight, highlight_style: inlay_highlight_style,
} }
} }
@ -801,7 +770,7 @@ impl InlaySnapshot {
{ {
assert_eq!( assert_eq!(
self.transforms.summary().input, 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<Transform>, summary: TextSummary) {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::{ use crate::{display_map::fold_map::FoldMap, MultiBuffer};
display_map::{fold_map::FoldMap, suggestion_map::SuggestionMap},
MultiBuffer,
};
use gpui::AppContext; use gpui::AppContext;
use rand::prelude::*; use rand::prelude::*;
use settings::SettingsStore; use settings::SettingsStore;
@ -846,8 +812,7 @@ mod tests {
let buffer = MultiBuffer::build_simple("abcdefghi", cx); let buffer = MultiBuffer::build_simple("abcdefghi", cx);
let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe()); let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe());
let (fold_map, fold_snapshot) = FoldMap::new(buffer.read(cx).snapshot(cx)); 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(fold_snapshot.clone());
let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone());
assert_eq!(inlay_snapshot.text(), "abcdefghi"); assert_eq!(inlay_snapshot.text(), "abcdefghi");
let mut next_inlay_id = 0; let mut next_inlay_id = 0;
@ -863,27 +828,27 @@ mod tests {
); );
assert_eq!(inlay_snapshot.text(), "abc|123|defghi"); assert_eq!(inlay_snapshot.text(), "abc|123|defghi");
assert_eq!( assert_eq!(
inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 0)), inlay_snapshot.to_inlay_point(FoldPoint::new(0, 0)),
InlayPoint::new(0, 0) InlayPoint::new(0, 0)
); );
assert_eq!( assert_eq!(
inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 1)), inlay_snapshot.to_inlay_point(FoldPoint::new(0, 1)),
InlayPoint::new(0, 1) InlayPoint::new(0, 1)
); );
assert_eq!( assert_eq!(
inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 2)), inlay_snapshot.to_inlay_point(FoldPoint::new(0, 2)),
InlayPoint::new(0, 2) InlayPoint::new(0, 2)
); );
assert_eq!( assert_eq!(
inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 3)), inlay_snapshot.to_inlay_point(FoldPoint::new(0, 3)),
InlayPoint::new(0, 3) InlayPoint::new(0, 3)
); );
assert_eq!( assert_eq!(
inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 4)), inlay_snapshot.to_inlay_point(FoldPoint::new(0, 4)),
InlayPoint::new(0, 9) InlayPoint::new(0, 9)
); );
assert_eq!( assert_eq!(
inlay_snapshot.to_inlay_point(SuggestionPoint::new(0, 5)), inlay_snapshot.to_inlay_point(FoldPoint::new(0, 5)),
InlayPoint::new(0, 10) InlayPoint::new(0, 10)
); );
assert_eq!( assert_eq!(
@ -919,9 +884,7 @@ mod tests {
buffer.read(cx).snapshot(cx), buffer.read(cx).snapshot(cx),
buffer_edits.consume().into_inner(), buffer_edits.consume().into_inner(),
); );
let (suggestion_snapshot, suggestion_edits) = let (inlay_snapshot, _) = inlay_map.sync(fold_snapshot.clone(), fold_edits);
suggestion_map.sync(fold_snapshot.clone(), fold_edits);
let (inlay_snapshot, _) = inlay_map.sync(suggestion_snapshot.clone(), suggestion_edits);
assert_eq!(inlay_snapshot.text(), "abxy|123|dzefghi"); assert_eq!(inlay_snapshot.text(), "abxy|123|dzefghi");
// An edit surrounding the inlay should invalidate it. // An edit surrounding the inlay should invalidate it.
@ -930,9 +893,7 @@ mod tests {
buffer.read(cx).snapshot(cx), buffer.read(cx).snapshot(cx),
buffer_edits.consume().into_inner(), buffer_edits.consume().into_inner(),
); );
let (suggestion_snapshot, suggestion_edits) = let (inlay_snapshot, _) = inlay_map.sync(fold_snapshot.clone(), fold_edits);
suggestion_map.sync(fold_snapshot.clone(), fold_edits);
let (inlay_snapshot, _) = inlay_map.sync(suggestion_snapshot.clone(), suggestion_edits);
assert_eq!(inlay_snapshot.text(), "abxyDzefghi"); assert_eq!(inlay_snapshot.text(), "abxyDzefghi");
let (inlay_snapshot, _) = inlay_map.splice( let (inlay_snapshot, _) = inlay_map.splice(
@ -962,9 +923,7 @@ mod tests {
buffer.read(cx).snapshot(cx), buffer.read(cx).snapshot(cx),
buffer_edits.consume().into_inner(), buffer_edits.consume().into_inner(),
); );
let (suggestion_snapshot, suggestion_edits) = let (inlay_snapshot, _) = inlay_map.sync(fold_snapshot.clone(), fold_edits);
suggestion_map.sync(fold_snapshot.clone(), fold_edits);
let (inlay_snapshot, _) = inlay_map.sync(suggestion_snapshot.clone(), suggestion_edits);
assert_eq!(inlay_snapshot.text(), "abx|123|JKL|456|yDzefghi"); assert_eq!(inlay_snapshot.text(), "abx|123|JKL|456|yDzefghi");
// The inlays can be manually removed. // The inlays can be manually removed.
@ -977,8 +936,7 @@ mod tests {
fn test_buffer_rows(cx: &mut AppContext) { fn test_buffer_rows(cx: &mut AppContext) {
let buffer = MultiBuffer::build_simple("abc\ndef\nghi", cx); let buffer = MultiBuffer::build_simple("abc\ndef\nghi", cx);
let (_, fold_snapshot) = FoldMap::new(buffer.read(cx).snapshot(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(fold_snapshot.clone());
let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone());
assert_eq!(inlay_snapshot.text(), "abc\ndef\nghi"); assert_eq!(inlay_snapshot.text(), "abc\ndef\nghi");
let (inlay_snapshot, _) = inlay_map.splice( let (inlay_snapshot, _) = inlay_map.splice(
@ -1035,12 +993,11 @@ mod tests {
log::info!("buffer text: {:?}", buffer_snapshot.text()); log::info!("buffer text: {:?}", buffer_snapshot.text());
let (mut fold_map, mut fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); 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(fold_snapshot.clone());
let (mut inlay_map, mut inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone());
let mut next_inlay_id = 0; let mut next_inlay_id = 0;
for _ in 0..operations { for _ in 0..operations {
let mut suggestion_edits = Patch::default(); let mut fold_edits = Patch::default();
let mut inlay_edits = Patch::default(); let mut inlay_edits = Patch::default();
let mut prev_inlay_text = inlay_snapshot.text(); let mut prev_inlay_text = inlay_snapshot.text();
@ -1052,10 +1009,8 @@ mod tests {
inlay_edits = Patch::new(edits); inlay_edits = Patch::new(edits);
} }
30..=59 => { 30..=59 => {
for (new_fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) { for (_, edits) in fold_map.randomly_mutate(&mut rng) {
fold_snapshot = new_fold_snapshot; fold_edits = fold_edits.compose(edits);
let (_, edits) = suggestion_map.sync(fold_snapshot.clone(), fold_edits);
suggestion_edits = suggestion_edits.compose(edits);
} }
} }
_ => buffer.update(cx, |buffer, cx| { _ => 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_map.read(buffer_snapshot.clone(), buffer_edits);
fold_snapshot = new_fold_snapshot; fold_snapshot = new_fold_snapshot;
let (new_suggestion_snapshot, new_suggestion_edits) = fold_edits = fold_edits.compose(new_fold_edits);
suggestion_map.sync(fold_snapshot.clone(), fold_edits);
suggestion_snapshot = new_suggestion_snapshot;
suggestion_edits = suggestion_edits.compose(new_suggestion_edits);
let (new_inlay_snapshot, new_inlay_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_snapshot = new_inlay_snapshot;
inlay_edits = inlay_edits.compose(new_inlay_edits); inlay_edits = inlay_edits.compose(new_inlay_edits);
log::info!("buffer text: {:?}", buffer_snapshot.text()); log::info!("buffer text: {:?}", buffer_snapshot.text());
log::info!("folds text: {:?}", fold_snapshot.text()); log::info!("folds text: {:?}", fold_snapshot.text());
log::info!("suggestions text: {:?}", suggestion_snapshot.text());
log::info!("inlay text: {:?}", inlay_snapshot.text()); log::info!("inlay text: {:?}", inlay_snapshot.text());
let inlays = inlay_map let inlays = inlay_map
@ -1093,12 +1044,11 @@ mod tests {
.map(|inlay| { .map(|inlay| {
let buffer_point = inlay.position.to_point(&buffer_snapshot); let buffer_point = inlay.position.to_point(&buffer_snapshot);
let fold_point = fold_snapshot.to_fold_point(buffer_point, Bias::Left); let fold_point = fold_snapshot.to_fold_point(buffer_point, Bias::Left);
let suggestion_point = suggestion_snapshot.to_suggestion_point(fold_point); let fold_offset = fold_point.to_offset(&fold_snapshot);
let suggestion_offset = suggestion_snapshot.to_offset(suggestion_point); (fold_offset, inlay.clone())
(suggestion_offset, inlay.clone())
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
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() { for (offset, inlay) in inlays.into_iter().rev() {
expected_text.replace(offset.0..offset.0, &inlay.text.to_string()); expected_text.replace(offset.0..offset.0, &inlay.text.to_string());
} }
@ -1172,11 +1122,11 @@ mod tests {
inlay_offset inlay_offset
); );
assert_eq!( 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), inlay_snapshot.clip_point(inlay_point, Bias::Left),
"to_suggestion_point({:?}) = {:?}", "to_fold_point({:?}) = {:?}",
inlay_point, inlay_point,
inlay_snapshot.to_suggestion_point(inlay_point), inlay_snapshot.to_fold_point(inlay_point),
); );
let mut bytes = [0; 4]; let mut bytes = [0; 4];

40
crates/editor/src/display_map/tab_map.rs
View file

@ -316,27 +316,15 @@ impl TabSnapshot {
} }
pub fn make_tab_point(&self, point: Point, bias: Bias) -> TabPoint { pub fn make_tab_point(&self, point: Point, bias: Bias) -> TabPoint {
let fold_point = self let fold_point = self.inlay_snapshot.fold_snapshot.to_fold_point(point, bias);
.inlay_snapshot let inlay_point = self.inlay_snapshot.to_inlay_point(fold_point);
.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);
self.to_tab_point(inlay_point) self.to_tab_point(inlay_point)
} }
pub fn to_point(&self, point: TabPoint, bias: Bias) -> Point { pub fn to_point(&self, point: TabPoint, bias: Bias) -> Point {
let inlay_point = self.to_inlay_point(point, bias).0; 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.to_fold_point(inlay_point);
let fold_point = self fold_point.to_buffer_point(&self.inlay_snapshot.fold_snapshot)
.inlay_snapshot
.suggestion_snapshot
.to_fold_point(suggestion_point);
fold_point.to_buffer_point(&self.inlay_snapshot.suggestion_snapshot.fold_snapshot)
} }
fn expand_tabs(&self, chars: impl Iterator<Item = char>, column: u32) -> u32 { fn expand_tabs(&self, chars: impl Iterator<Item = char>, column: u32) -> u32 {
@ -579,7 +567,7 @@ impl<'a> Iterator for TabChunks<'a> {
mod tests { mod tests {
use super::*; use super::*;
use crate::{ use crate::{
display_map::{fold_map::FoldMap, inlay_map::InlayMap, suggestion_map::SuggestionMap}, display_map::{fold_map::FoldMap, inlay_map::InlayMap},
MultiBuffer, MultiBuffer,
}; };
use rand::{prelude::StdRng, Rng}; use rand::{prelude::StdRng, Rng};
@ -589,8 +577,7 @@ mod tests {
let buffer = MultiBuffer::build_simple("", cx); let buffer = MultiBuffer::build_simple("", cx);
let buffer_snapshot = buffer.read(cx).snapshot(cx); let buffer_snapshot = buffer.read(cx).snapshot(cx);
let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); let (_, inlay_snapshot) = InlayMap::new(fold_snapshot);
let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap());
assert_eq!(tab_snapshot.expand_tabs("\t".chars(), 0), 0); 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 = MultiBuffer::build_simple(input, cx);
let buffer_snapshot = buffer.read(cx).snapshot(cx); let buffer_snapshot = buffer.read(cx).snapshot(cx);
let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); let (_, inlay_snapshot) = InlayMap::new(fold_snapshot);
let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, mut tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); let (_, mut tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap());
tab_snapshot.max_expansion_column = max_expansion_column; tab_snapshot.max_expansion_column = max_expansion_column;
@ -656,8 +642,7 @@ mod tests {
let buffer = MultiBuffer::build_simple(input, cx); let buffer = MultiBuffer::build_simple(input, cx);
let buffer_snapshot = buffer.read(cx).snapshot(cx); let buffer_snapshot = buffer.read(cx).snapshot(cx);
let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); let (_, inlay_snapshot) = InlayMap::new(fold_snapshot);
let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, mut tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); let (_, mut tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap());
tab_snapshot.max_expansion_column = max_expansion_column; tab_snapshot.max_expansion_column = max_expansion_column;
@ -671,8 +656,7 @@ mod tests {
let buffer = MultiBuffer::build_simple(&input, cx); let buffer = MultiBuffer::build_simple(&input, cx);
let buffer_snapshot = buffer.read(cx).snapshot(cx); let buffer_snapshot = buffer.read(cx).snapshot(cx);
let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot); let (_, inlay_snapshot) = InlayMap::new(fold_snapshot);
let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap()); let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap());
assert_eq!( assert_eq!(
@ -734,10 +718,8 @@ mod tests {
fold_map.randomly_mutate(&mut rng); fold_map.randomly_mutate(&mut rng);
let (fold_snapshot, _) = fold_map.read(buffer_snapshot, vec![]); let (fold_snapshot, _) = fold_map.read(buffer_snapshot, vec![]);
log::info!("FoldMap text: {:?}", fold_snapshot.text()); log::info!("FoldMap text: {:?}", fold_snapshot.text());
let (suggestion_map, _) = SuggestionMap::new(fold_snapshot); let (mut inlay_map, _) = InlayMap::new(fold_snapshot.clone());
let (suggestion_snapshot, _) = suggestion_map.randomly_mutate(&mut rng); let (inlay_snapshot, _) = inlay_map.randomly_mutate(&mut 0, &mut rng);
log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone());
log::info!("InlayMap text: {:?}", inlay_snapshot.text()); log::info!("InlayMap text: {:?}", inlay_snapshot.text());
let (tab_map, _) = TabMap::new(inlay_snapshot.clone(), tab_size); let (tab_map, _) = TabMap::new(inlay_snapshot.clone(), tab_size);

43
crates/editor/src/display_map/wrap_map.rs
View file

@ -763,25 +763,12 @@ impl WrapSnapshot {
for display_row in 0..=self.max_point().row() { for display_row in 0..=self.max_point().row() {
let tab_point = self.to_tab_point(WrapPoint::new(display_row, 0)); 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 inlay_point = self.tab_snapshot.to_inlay_point(tab_point, Bias::Left).0;
let suggestion_point = self let fold_point = self.tab_snapshot.inlay_snapshot.to_fold_point(inlay_point);
.tab_snapshot
.inlay_snapshot
.to_suggestion_point(inlay_point);
let fold_point = self
.tab_snapshot
.inlay_snapshot
.suggestion_snapshot
.to_fold_point(suggestion_point);
if fold_point.row() == prev_fold_row && display_row != 0 { if fold_point.row() == prev_fold_row && display_row != 0 {
expected_buffer_rows.push(None); expected_buffer_rows.push(None);
} else { } else {
let buffer_point = fold_point.to_buffer_point( let buffer_point =
&self fold_point.to_buffer_point(&self.tab_snapshot.inlay_snapshot.fold_snapshot);
.tab_snapshot
.inlay_snapshot
.suggestion_snapshot
.fold_snapshot,
);
expected_buffer_rows.push(input_buffer_rows[buffer_point.row as usize]); expected_buffer_rows.push(input_buffer_rows[buffer_point.row as usize]);
prev_fold_row = fold_point.row(); prev_fold_row = fold_point.row();
} }
@ -1045,9 +1032,7 @@ fn consolidate_wrap_edits(edits: &mut Vec<WrapEdit>) {
mod tests { mod tests {
use super::*; use super::*;
use crate::{ use crate::{
display_map::{ display_map::{fold_map::FoldMap, inlay_map::InlayMap, tab_map::TabMap},
fold_map::FoldMap, inlay_map::InlayMap, suggestion_map::SuggestionMap, tab_map::TabMap,
},
MultiBuffer, MultiBuffer,
}; };
use gpui::test::observe; use gpui::test::observe;
@ -1100,9 +1085,7 @@ mod tests {
log::info!("Buffer text: {:?}", buffer_snapshot.text()); log::info!("Buffer text: {:?}", buffer_snapshot.text());
let (mut fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone()); let (mut fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
log::info!("FoldMap text: {:?}", fold_snapshot.text()); log::info!("FoldMap text: {:?}", fold_snapshot.text());
let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone()); let (mut inlay_map, inlay_snapshot) = InlayMap::new(fold_snapshot.clone());
log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
let (mut inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone());
log::info!("InlaysMap text: {:?}", inlay_snapshot.text()); log::info!("InlaysMap text: {:?}", inlay_snapshot.text());
let (tab_map, _) = TabMap::new(inlay_snapshot.clone(), tab_size); let (tab_map, _) = TabMap::new(inlay_snapshot.clone(), tab_size);
let tabs_snapshot = tab_map.set_max_expansion_column(32); let tabs_snapshot = tab_map.set_max_expansion_column(32);
@ -1133,6 +1116,7 @@ mod tests {
); );
log::info!("Wrapped text: {:?}", actual_text); log::info!("Wrapped text: {:?}", actual_text);
let mut next_inlay_id = 0;
let mut edits = Vec::new(); let mut edits = Vec::new();
for _i in 0..operations { for _i in 0..operations {
log::info!("{} ==============================================", _i); log::info!("{} ==============================================", _i);
@ -1150,10 +1134,8 @@ mod tests {
} }
20..=39 => { 20..=39 => {
for (fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) { 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) = let (inlay_snapshot, inlay_edits) =
inlay_map.sync(suggestion_snapshot, suggestion_edits); inlay_map.sync(fold_snapshot, fold_edits);
let (tabs_snapshot, tab_edits) = let (tabs_snapshot, tab_edits) =
tab_map.sync(inlay_snapshot, inlay_edits, tab_size); tab_map.sync(inlay_snapshot, inlay_edits, tab_size);
let (mut snapshot, wrap_edits) = let (mut snapshot, wrap_edits) =
@ -1164,10 +1146,8 @@ mod tests {
} }
} }
40..=59 => { 40..=59 => {
let (suggestion_snapshot, suggestion_edits) =
suggestion_map.randomly_mutate(&mut rng);
let (inlay_snapshot, inlay_edits) = 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) = let (tabs_snapshot, tab_edits) =
tab_map.sync(inlay_snapshot, inlay_edits, tab_size); tab_map.sync(inlay_snapshot, inlay_edits, tab_size);
let (mut snapshot, wrap_edits) = let (mut snapshot, wrap_edits) =
@ -1190,11 +1170,8 @@ mod tests {
log::info!("Buffer text: {:?}", buffer_snapshot.text()); log::info!("Buffer text: {:?}", buffer_snapshot.text());
let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits); let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
log::info!("FoldMap text: {:?}", fold_snapshot.text()); log::info!("FoldMap text: {:?}", fold_snapshot.text());
let (suggestion_snapshot, suggestion_edits) = let (inlay_snapshot, inlay_edits) = inlay_map.sync(fold_snapshot, fold_edits);
suggestion_map.sync(fold_snapshot, fold_edits); log::info!("InlayMap text: {:?}", inlay_snapshot.text());
log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tabs_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size); let (tabs_snapshot, tab_edits) = tab_map.sync(inlay_snapshot, inlay_edits, tab_size);
log::info!("TabMap text: {:?}", tabs_snapshot.text()); log::info!("TabMap text: {:?}", tabs_snapshot.text());