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

Rename the new map

Browse source
This commit is contained in:
Kirill Bulatov 2023-06-07 23:29:27 +03:00
parent 9287634548
commit b5233b3ad5
5 changed files with 190 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,6 +1,6 @@
mod block_map; mod block_map;
mod editor_addition_map;
mod fold_map; mod fold_map;
mod inlay_map;
mod suggestion_map; mod suggestion_map;
mod tab_map; mod tab_map;
mod wrap_map; mod wrap_map;
@ -8,13 +8,13 @@ mod wrap_map;
use crate::{Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint}; use crate::{Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint};
pub use block_map::{BlockMap, BlockPoint}; pub use block_map::{BlockMap, BlockPoint};
use collections::{HashMap, HashSet}; use collections::{HashMap, HashSet};
use editor_addition_map::EditorAdditionMap;
use fold_map::{FoldMap, FoldOffset}; use fold_map::{FoldMap, FoldOffset};
use gpui::{ use gpui::{
color::Color, color::Color,
fonts::{FontId, HighlightStyle}, fonts::{FontId, HighlightStyle},
Entity, ModelContext, ModelHandle, Entity, ModelContext, ModelHandle,
}; };
use inlay_map::InlayMap;
use language::{ use language::{
language_settings::language_settings, OffsetUtf16, Point, Subscription as BufferSubscription, language_settings::language_settings, OffsetUtf16, Point, Subscription as BufferSubscription,
}; };
@ -30,7 +30,7 @@ pub use block_map::{
BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock, TransformBlock, BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock, TransformBlock,
}; };
use self::editor_addition_map::InlayHintToRender; use self::inlay_map::InlayHintToRender;
#[derive(Copy, Clone, Debug, PartialEq, Eq)] #[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum FoldStatus { pub enum FoldStatus {
@ -49,7 +49,7 @@ pub struct DisplayMap {
buffer_subscription: BufferSubscription, buffer_subscription: BufferSubscription,
fold_map: FoldMap, fold_map: FoldMap,
suggestion_map: SuggestionMap, suggestion_map: SuggestionMap,
editor_addition_map: EditorAdditionMap, inlay_map: InlayMap,
tab_map: TabMap, tab_map: TabMap,
wrap_map: ModelHandle<WrapMap>, wrap_map: ModelHandle<WrapMap>,
block_map: BlockMap, block_map: BlockMap,
@ -76,7 +76,7 @@ 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 (suggestion_map, snapshot) = SuggestionMap::new(snapshot);
let (editor_addition_map, snapshot) = EditorAdditionMap::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);
let block_map = BlockMap::new(snapshot, buffer_header_height, excerpt_header_height); let block_map = BlockMap::new(snapshot, buffer_header_height, excerpt_header_height);
@ -86,7 +86,7 @@ impl DisplayMap {
buffer_subscription, buffer_subscription,
fold_map, fold_map,
suggestion_map, suggestion_map,
editor_addition_map, inlay_map,
tab_map, tab_map,
wrap_map, wrap_map,
block_map, block_map,
@ -100,13 +100,13 @@ impl DisplayMap {
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 (suggestion_snapshot, edits) = self.suggestion_map.sync(fold_snapshot.clone(), edits);
let (editor_addition_snapshot, edits) = self let (inlay_snapshot, edits) = self
.editor_addition_map .inlay_map
.sync(suggestion_snapshot.clone(), edits); .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) = let (tab_snapshot, edits) =
self.tab_map self.tab_map
.sync(editor_addition_snapshot.clone(), edits, tab_size); .sync(inlay_snapshot.clone(), edits, tab_size);
let (wrap_snapshot, edits) = self let (wrap_snapshot, edits) = self
.wrap_map .wrap_map
.update(cx, |map, cx| map.sync(tab_snapshot.clone(), edits, cx)); .update(cx, |map, cx| map.sync(tab_snapshot.clone(), edits, cx));
@ -116,7 +116,7 @@ impl DisplayMap {
buffer_snapshot: self.buffer.read(cx).snapshot(cx), buffer_snapshot: self.buffer.read(cx).snapshot(cx),
fold_snapshot, fold_snapshot,
suggestion_snapshot, suggestion_snapshot,
editor_addition_snapshot, inlay_snapshot,
tab_snapshot, tab_snapshot,
wrap_snapshot, wrap_snapshot,
block_snapshot, block_snapshot,
@ -144,7 +144,7 @@ impl DisplayMap {
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.suggestion_map.sync(snapshot, edits);
let (snapshot, edits) = self.editor_addition_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
.wrap_map .wrap_map
@ -152,7 +152,7 @@ impl DisplayMap {
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.suggestion_map.sync(snapshot, edits);
let (snapshot, edits) = self.editor_addition_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
.wrap_map .wrap_map
@ -171,7 +171,7 @@ impl DisplayMap {
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.suggestion_map.sync(snapshot, edits);
let (snapshot, edits) = self.editor_addition_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
.wrap_map .wrap_map
@ -179,7 +179,7 @@ impl DisplayMap {
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.suggestion_map.sync(snapshot, edits);
let (snapshot, edits) = self.editor_addition_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
.wrap_map .wrap_map
@ -197,7 +197,7 @@ impl DisplayMap {
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.suggestion_map.sync(snapshot, edits);
let (snapshot, edits) = self.editor_addition_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
.wrap_map .wrap_map
@ -216,7 +216,7 @@ impl DisplayMap {
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.suggestion_map.sync(snapshot, edits);
let (snapshot, edits) = self.editor_addition_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
.wrap_map .wrap_map
@ -265,7 +265,7 @@ impl DisplayMap {
let (snapshot, edits) = self.fold_map.read(snapshot, edits); let (snapshot, edits) = self.fold_map.read(snapshot, edits);
let (snapshot, edits, old_suggestion) = let (snapshot, edits, old_suggestion) =
self.suggestion_map.replace(new_suggestion, snapshot, edits); self.suggestion_map.replace(new_suggestion, snapshot, edits);
let (snapshot, edits) = self.editor_addition_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
.wrap_map .wrap_map
@ -302,7 +302,7 @@ impl DisplayMap {
.map(|buffer_handle| buffer_handle.id()) .map(|buffer_handle| buffer_handle.id())
.collect::<HashSet<_>>()); .collect::<HashSet<_>>());
self.editor_addition_map.set_inlay_hints( self.inlay_map.set_inlay_hints(
new_hints new_hints
.into_iter() .into_iter()
.filter_map(|hint| { .filter_map(|hint| {
@ -312,9 +312,10 @@ impl DisplayMap {
let buffer = dbg!(multi_buffer.buffer(dbg!(hint.buffer_id)))?.read(cx); let buffer = dbg!(multi_buffer.buffer(dbg!(hint.buffer_id)))?.read(cx);
let snapshot = buffer.snapshot(); let snapshot = buffer.snapshot();
Some(InlayHintToRender { Some(InlayHintToRender {
position: editor_addition_map::EditorAdditionPoint( position: inlay_map::InlayPoint(text::ToPoint::to_point(
text::ToPoint::to_point(&hint.position, &snapshot), &hint.position,
), &snapshot,
)),
text: hint.text().trim_end().into(), text: hint.text().trim_end().into(),
}) })
}) })
@ -340,7 +341,7 @@ 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, suggestion_snapshot: suggestion_map::SuggestionSnapshot,
editor_addition_snapshot: editor_addition_map::EditorAdditionSnapshot, 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,
block_snapshot: block_map::BlockSnapshot, block_snapshot: block_map::BlockSnapshot,
@ -418,10 +419,10 @@ 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 suggestion_point = self.suggestion_snapshot.to_suggestion_point(fold_point);
let editor_addition_point = self let inlay_point = self
.editor_addition_snapshot .inlay_snapshot
.to_editor_addition_point(suggestion_point); .to_inlay_point(suggestion_point);
let tab_point = self.tab_snapshot.to_tab_point(editor_addition_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);
DisplayPoint(block_point) DisplayPoint(block_point)
@ -431,13 +432,13 @@ impl DisplaySnapshot {
let block_point = point.0; let block_point = point.0;
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 editor_addition_point = self let inlay_point = self
.tab_snapshot .tab_snapshot
.to_editor_addition_point(tab_point, bias) .to_inlay_point(tab_point, bias)
.0; .0;
let suggestion_point = self let suggestion_point = self
.editor_addition_snapshot .inlay_snapshot
.to_suggestion_point(editor_addition_point, bias); .to_suggestion_point(inlay_point, bias);
let fold_point = self.suggestion_snapshot.to_fold_point(suggestion_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)
} }
@ -851,10 +852,10 @@ impl DisplayPoint {
pub fn to_offset(self, map: &DisplaySnapshot, bias: Bias) -> usize { pub fn to_offset(self, map: &DisplaySnapshot, bias: Bias) -> usize {
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 editor_addition_point = map.tab_snapshot.to_editor_addition_point(tab_point, bias).0; let inlay_point = map.tab_snapshot.to_inlay_point(tab_point, bias).0;
let suggestion_point = map let suggestion_point = map
.editor_addition_snapshot .inlay_snapshot
.to_suggestion_point(editor_addition_point, bias); .to_suggestion_point(inlay_point, bias);
let fold_point = map.suggestion_snapshot.to_fold_point(suggestion_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)
} }

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

@ -989,7 +989,7 @@ fn offset_for_row(s: &str, target: u32) -> (u32, usize) {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::display_map::editor_addition_map::EditorAdditionMap; use crate::display_map::inlay_map::InlayMap;
use crate::display_map::suggestion_map::SuggestionMap; 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;
@ -1033,9 +1033,8 @@ mod tests {
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 (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
let (editor_addition_map, editor_addition_snapshot) = let (inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
EditorAdditionMap::new(suggestion_snapshot); let (tab_map, tab_snapshot) = TabMap::new(inlay_snapshot, 1.try_into().unwrap());
let (tab_map, tab_snapshot) = TabMap::new(editor_addition_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);
@ -1182,13 +1181,10 @@ mod tests {
fold_map.read(buffer_snapshot, subscription.consume().into_inner()); fold_map.read(buffer_snapshot, subscription.consume().into_inner());
let (suggestion_snapshot, suggestion_edits) = let (suggestion_snapshot, suggestion_edits) =
suggestion_map.sync(fold_snapshot, fold_edits); suggestion_map.sync(fold_snapshot, fold_edits);
let (editor_addition_snapshot, editor_addition_edits) = let (inlay_snapshot, inlay_edits) =
editor_addition_map.sync(suggestion_snapshot, suggestion_edits); inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tab_snapshot, tab_edits) = tab_map.sync( let (tab_snapshot, tab_edits) =
editor_addition_snapshot, tab_map.sync(inlay_snapshot, inlay_edits, 4.try_into().unwrap());
editor_addition_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| {
wrap_map.sync(tab_snapshot, tab_edits, cx) wrap_map.sync(tab_snapshot, tab_edits, cx)
}); });
@ -1215,8 +1211,8 @@ mod tests {
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 (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
let (_, editor_addition_snapshot) = EditorAdditionMap::new(suggestion_snapshot); let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, tab_snapshot) = TabMap::new(editor_addition_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);
@ -1288,9 +1284,8 @@ 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 (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
let (editor_addition_map, editor_addition_snapshot) = let (inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
EditorAdditionMap::new(suggestion_snapshot); let (tab_map, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap());
let (tab_map, tab_snapshot) = TabMap::new(editor_addition_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);
let mut block_map = BlockMap::new( let mut block_map = BlockMap::new(
@ -1347,10 +1342,10 @@ mod tests {
fold_map.read(buffer_snapshot.clone(), vec![]); fold_map.read(buffer_snapshot.clone(), vec![]);
let (suggestion_snapshot, suggestion_edits) = let (suggestion_snapshot, suggestion_edits) =
suggestion_map.sync(fold_snapshot, fold_edits); suggestion_map.sync(fold_snapshot, fold_edits);
let (editor_addition_snapshot, editor_addition_edits) = let (inlay_snapshot, inlay_edits) =
editor_addition_map.sync(suggestion_snapshot, suggestion_edits); inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tab_snapshot, tab_edits) = let (tab_snapshot, tab_edits) =
tab_map.sync(editor_addition_snapshot, editor_addition_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| {
wrap_map.sync(tab_snapshot, tab_edits, cx) wrap_map.sync(tab_snapshot, tab_edits, cx)
}); });
@ -1374,10 +1369,10 @@ mod tests {
fold_map.read(buffer_snapshot.clone(), vec![]); fold_map.read(buffer_snapshot.clone(), vec![]);
let (suggestion_snapshot, suggestion_edits) = let (suggestion_snapshot, suggestion_edits) =
suggestion_map.sync(fold_snapshot, fold_edits); suggestion_map.sync(fold_snapshot, fold_edits);
let (editor_addition_snapshot, editor_addition_edits) = let (inlay_snapshot, inlay_edits) =
editor_addition_map.sync(suggestion_snapshot, suggestion_edits); inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tab_snapshot, tab_edits) = let (tab_snapshot, tab_edits) =
tab_map.sync(editor_addition_snapshot, editor_addition_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| {
wrap_map.sync(tab_snapshot, tab_edits, cx) wrap_map.sync(tab_snapshot, tab_edits, cx)
}); });
@ -1399,10 +1394,10 @@ 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 (suggestion_snapshot, suggestion_edits) =
suggestion_map.sync(fold_snapshot, fold_edits); suggestion_map.sync(fold_snapshot, fold_edits);
let (editor_addition_snapshot, editor_addition_edits) = let (inlay_snapshot, inlay_edits) =
editor_addition_map.sync(suggestion_snapshot, suggestion_edits); inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tab_snapshot, tab_edits) = let (tab_snapshot, tab_edits) =
tab_map.sync(editor_addition_snapshot, editor_addition_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| {
wrap_map.sync(tab_snapshot, tab_edits, cx) wrap_map.sync(tab_snapshot, tab_edits, cx)
}); });

86
crates/editor/src/display_map/editor_addition_map.rs → crates/editor/src/display_map/inlay_map.rs
View file

@ -26,14 +26,14 @@ use sum_tree::{Bias, SumTree};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct InlayHintId(usize); pub struct InlayHintId(usize);
pub struct EditorAdditionMap { pub struct InlayMap {
snapshot: Mutex<EditorAdditionSnapshot>, snapshot: Mutex<InlaySnapshot>,
next_hint_id: AtomicUsize, next_hint_id: AtomicUsize,
hints: HashMap<InlayHintId, InlayHintToRender>, hints: HashMap<InlayHintId, InlayHintToRender>,
} }
#[derive(Clone)] #[derive(Clone)]
pub struct EditorAdditionSnapshot { pub struct InlaySnapshot {
// TODO kb merge these two together // TODO kb merge these two together
pub suggestion_snapshot: SuggestionSnapshot, pub suggestion_snapshot: SuggestionSnapshot,
transforms: SumTree<Transform>, transforms: SumTree<Transform>,
@ -54,12 +54,12 @@ impl sum_tree::Item for Transform {
} }
} }
pub type EditorAdditionEdit = Edit<EditorAdditionOffset>; pub type InlayEdit = Edit<InlayOffset>;
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)] #[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
pub struct EditorAdditionOffset(pub usize); pub struct InlayOffset(pub usize);
impl Add for EditorAdditionOffset { impl Add for InlayOffset {
type Output = Self; type Output = Self;
fn add(self, rhs: Self) -> Self::Output { fn add(self, rhs: Self) -> Self::Output {
@ -67,7 +67,7 @@ impl Add for EditorAdditionOffset {
} }
} }
impl Sub for EditorAdditionOffset { impl Sub for InlayOffset {
type Output = Self; type Output = Self;
fn sub(self, rhs: Self) -> Self::Output { fn sub(self, rhs: Self) -> Self::Output {
@ -75,31 +75,31 @@ impl Sub for EditorAdditionOffset {
} }
} }
impl AddAssign for EditorAdditionOffset { impl AddAssign for InlayOffset {
fn add_assign(&mut self, rhs: Self) { fn add_assign(&mut self, rhs: Self) {
self.0 += rhs.0; self.0 += rhs.0;
} }
} }
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)] #[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
pub struct EditorAdditionPoint(pub Point); pub struct InlayPoint(pub Point);
#[derive(Clone)] #[derive(Clone)]
pub struct EditorAdditionBufferRows<'a> { pub struct InlayBufferRows<'a> {
suggestion_rows: SuggestionBufferRows<'a>, suggestion_rows: SuggestionBufferRows<'a>,
} }
pub struct EditorAdditionChunks<'a> { pub struct InlayChunks<'a> {
suggestion_chunks: SuggestionChunks<'a>, suggestion_chunks: SuggestionChunks<'a>,
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct InlayHintToRender { pub struct InlayHintToRender {
pub(super) position: EditorAdditionPoint, pub(super) position: InlayPoint,
pub(super) text: Rope, pub(super) text: Rope,
} }
impl<'a> Iterator for EditorAdditionChunks<'a> { impl<'a> Iterator for InlayChunks<'a> {
type Item = Chunk<'a>; type Item = Chunk<'a>;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
@ -107,7 +107,7 @@ impl<'a> Iterator for EditorAdditionChunks<'a> {
} }
} }
impl<'a> Iterator for EditorAdditionBufferRows<'a> { impl<'a> Iterator for InlayBufferRows<'a> {
type Item = Option<u32>; type Item = Option<u32>;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
@ -115,7 +115,7 @@ impl<'a> Iterator for EditorAdditionBufferRows<'a> {
} }
} }
impl EditorAdditionPoint { impl InlayPoint {
pub fn new(row: u32, column: u32) -> Self { pub fn new(row: u32, column: u32) -> Self {
Self(Point::new(row, column)) Self(Point::new(row, column))
} }
@ -129,9 +129,9 @@ impl EditorAdditionPoint {
} }
} }
impl EditorAdditionMap { impl InlayMap {
pub fn new(suggestion_snapshot: SuggestionSnapshot) -> (Self, EditorAdditionSnapshot) { pub fn new(suggestion_snapshot: SuggestionSnapshot) -> (Self, InlaySnapshot) {
let snapshot = EditorAdditionSnapshot { let snapshot = InlaySnapshot {
suggestion_snapshot: suggestion_snapshot.clone(), suggestion_snapshot: suggestion_snapshot.clone(),
version: 0, version: 0,
transforms: SumTree::new(), transforms: SumTree::new(),
@ -151,29 +151,29 @@ impl EditorAdditionMap {
&self, &self,
suggestion_snapshot: SuggestionSnapshot, suggestion_snapshot: SuggestionSnapshot,
suggestion_edits: Vec<SuggestionEdit>, suggestion_edits: Vec<SuggestionEdit>,
) -> (EditorAdditionSnapshot, Vec<EditorAdditionEdit>) { ) -> (InlaySnapshot, Vec<InlayEdit>) {
let mut snapshot = self.snapshot.lock(); let mut snapshot = self.snapshot.lock();
if snapshot.suggestion_snapshot.version != suggestion_snapshot.version { if snapshot.suggestion_snapshot.version != suggestion_snapshot.version {
snapshot.version += 1; snapshot.version += 1;
} }
let mut editor_addition_edits = Vec::new(); let mut inlay_edits = Vec::new();
dbg!(&suggestion_edits); dbg!(&suggestion_edits);
for suggestion_edit in suggestion_edits { for suggestion_edit in suggestion_edits {
let old = suggestion_edit.old; let old = suggestion_edit.old;
let new = suggestion_edit.new; let new = suggestion_edit.new;
// TODO kb copied from suggestion_map // TODO kb copied from suggestion_map
editor_addition_edits.push(EditorAdditionEdit { inlay_edits.push(InlayEdit {
old: EditorAdditionOffset(old.start.0)..EditorAdditionOffset(old.end.0), old: InlayOffset(old.start.0)..InlayOffset(old.end.0),
new: EditorAdditionOffset(old.start.0)..EditorAdditionOffset(new.end.0), new: InlayOffset(old.start.0)..InlayOffset(new.end.0),
}) })
} }
snapshot.suggestion_snapshot = suggestion_snapshot; snapshot.suggestion_snapshot = suggestion_snapshot;
(snapshot.clone(), editor_addition_edits) (snapshot.clone(), inlay_edits)
} }
// TODO kb replace set_inlay_hints with this // TODO kb replace set_inlay_hints with this
@ -204,57 +204,57 @@ impl EditorAdditionMap {
} }
} }
impl EditorAdditionSnapshot { impl InlaySnapshot {
pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot { pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot {
// TODO kb copied from suggestion_map // TODO kb copied from suggestion_map
self.suggestion_snapshot.buffer_snapshot() self.suggestion_snapshot.buffer_snapshot()
} }
pub fn to_point(&self, offset: EditorAdditionOffset) -> EditorAdditionPoint { pub fn to_point(&self, offset: InlayOffset) -> InlayPoint {
// TODO kb copied from suggestion_map // TODO kb copied from suggestion_map
self.to_editor_addition_point( self.to_inlay_point(
self.suggestion_snapshot self.suggestion_snapshot
.to_point(super::suggestion_map::SuggestionOffset(offset.0)), .to_point(super::suggestion_map::SuggestionOffset(offset.0)),
) )
} }
pub fn max_point(&self) -> EditorAdditionPoint { pub fn max_point(&self) -> InlayPoint {
// TODO kb copied from suggestion_map // TODO kb copied from suggestion_map
self.to_editor_addition_point(self.suggestion_snapshot.max_point()) self.to_inlay_point(self.suggestion_snapshot.max_point())
} }
pub fn to_offset(&self, point: EditorAdditionPoint) -> EditorAdditionOffset { pub fn to_offset(&self, point: InlayPoint) -> InlayOffset {
// TODO kb copied from suggestion_map // TODO kb copied from suggestion_map
EditorAdditionOffset( InlayOffset(
self.suggestion_snapshot self.suggestion_snapshot
.to_offset(self.to_suggestion_point(point, Bias::Left)) .to_offset(self.to_suggestion_point(point, Bias::Left))
.0, .0,
) )
} }
pub fn chars_at(&self, start: EditorAdditionPoint) -> impl '_ + Iterator<Item = char> { pub fn chars_at(&self, start: InlayPoint) -> impl '_ + Iterator<Item = char> {
self.suggestion_snapshot self.suggestion_snapshot
.chars_at(self.to_suggestion_point(start, Bias::Left)) .chars_at(self.to_suggestion_point(start, Bias::Left))
} }
// TODO kb what to do with bias? // TODO kb what to do with bias?
pub fn to_suggestion_point(&self, point: EditorAdditionPoint, _: Bias) -> SuggestionPoint { pub fn to_suggestion_point(&self, point: InlayPoint, _: Bias) -> SuggestionPoint {
SuggestionPoint(point.0) SuggestionPoint(point.0)
} }
pub fn to_editor_addition_point(&self, point: SuggestionPoint) -> EditorAdditionPoint { pub fn to_inlay_point(&self, point: SuggestionPoint) -> InlayPoint {
EditorAdditionPoint(point.0) InlayPoint(point.0)
} }
pub fn clip_point(&self, point: EditorAdditionPoint, bias: Bias) -> EditorAdditionPoint { pub fn clip_point(&self, point: InlayPoint, bias: Bias) -> InlayPoint {
// TODO kb copied from suggestion_map // TODO kb copied from suggestion_map
self.to_editor_addition_point( self.to_inlay_point(
self.suggestion_snapshot self.suggestion_snapshot
.clip_point(self.to_suggestion_point(point, bias), bias), .clip_point(self.to_suggestion_point(point, bias), bias),
) )
} }
pub fn text_summary_for_range(&self, range: Range<EditorAdditionPoint>) -> TextSummary { pub fn text_summary_for_range(&self, range: Range<InlayPoint>) -> TextSummary {
// TODO kb copied from suggestion_map // TODO kb copied from suggestion_map
self.suggestion_snapshot.text_summary_for_range( self.suggestion_snapshot.text_summary_for_range(
self.to_suggestion_point(range.start, Bias::Left) self.to_suggestion_point(range.start, Bias::Left)
@ -262,8 +262,8 @@ impl EditorAdditionSnapshot {
) )
} }
pub fn buffer_rows<'a>(&'a self, row: u32) -> EditorAdditionBufferRows<'a> { pub fn buffer_rows<'a>(&'a self, row: u32) -> InlayBufferRows<'a> {
EditorAdditionBufferRows { InlayBufferRows {
suggestion_rows: self.suggestion_snapshot.buffer_rows(row), suggestion_rows: self.suggestion_snapshot.buffer_rows(row),
} }
} }
@ -275,13 +275,13 @@ impl EditorAdditionSnapshot {
pub fn chunks<'a>( pub fn chunks<'a>(
&'a self, &'a self,
range: Range<EditorAdditionOffset>, range: Range<InlayOffset>,
language_aware: bool, language_aware: bool,
text_highlights: Option<&'a TextHighlights>, text_highlights: Option<&'a TextHighlights>,
suggestion_highlight: Option<HighlightStyle>, suggestion_highlight: Option<HighlightStyle>,
) -> EditorAdditionChunks<'a> { ) -> InlayChunks<'a> {
// TODO kb copied from suggestion_map // TODO kb copied from suggestion_map
EditorAdditionChunks { InlayChunks {
suggestion_chunks: self.suggestion_snapshot.chunks( suggestion_chunks: self.suggestion_snapshot.chunks(
SuggestionOffset(range.start.0)..SuggestionOffset(range.end.0), SuggestionOffset(range.start.0)..SuggestionOffset(range.end.0),
language_aware, language_aware,

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

@ -1,7 +1,5 @@
use super::{ use super::{
editor_addition_map::{ inlay_map::{self, InlayChunks, InlayEdit, InlayPoint, InlaySnapshot},
self, EditorAdditionChunks, EditorAdditionEdit, EditorAdditionPoint, EditorAdditionSnapshot,
},
TextHighlights, TextHighlights,
}; };
use crate::MultiBufferSnapshot; use crate::MultiBufferSnapshot;
@ -16,9 +14,9 @@ const MAX_EXPANSION_COLUMN: u32 = 256;
pub struct TabMap(Mutex<TabSnapshot>); pub struct TabMap(Mutex<TabSnapshot>);
impl TabMap { impl TabMap {
pub fn new(input: EditorAdditionSnapshot, tab_size: NonZeroU32) -> (Self, TabSnapshot) { pub fn new(input: InlaySnapshot, tab_size: NonZeroU32) -> (Self, TabSnapshot) {
let snapshot = TabSnapshot { let snapshot = TabSnapshot {
editor_addition_snapshot: input, inlay_snapshot: input,
tab_size, tab_size,
max_expansion_column: MAX_EXPANSION_COLUMN, max_expansion_column: MAX_EXPANSION_COLUMN,
version: 0, version: 0,
@ -34,20 +32,20 @@ impl TabMap {
pub fn sync( pub fn sync(
&self, &self,
editor_addition_snapshot: EditorAdditionSnapshot, inlay_snapshot: InlaySnapshot,
mut suggestion_edits: Vec<EditorAdditionEdit>, mut suggestion_edits: Vec<InlayEdit>,
tab_size: NonZeroU32, tab_size: NonZeroU32,
) -> (TabSnapshot, Vec<TabEdit>) { ) -> (TabSnapshot, Vec<TabEdit>) {
let mut old_snapshot = self.0.lock(); let mut old_snapshot = self.0.lock();
let mut new_snapshot = TabSnapshot { let mut new_snapshot = TabSnapshot {
editor_addition_snapshot, inlay_snapshot,
tab_size, tab_size,
max_expansion_column: old_snapshot.max_expansion_column, max_expansion_column: old_snapshot.max_expansion_column,
version: old_snapshot.version, version: old_snapshot.version,
}; };
if old_snapshot.editor_addition_snapshot.version if old_snapshot.inlay_snapshot.version
!= new_snapshot.editor_addition_snapshot.version != new_snapshot.inlay_snapshot.version
{ {
new_snapshot.version += 1; new_snapshot.version += 1;
} }
@ -60,21 +58,21 @@ impl TabMap {
// boundary. // boundary.
for suggestion_edit in &mut suggestion_edits { for suggestion_edit in &mut suggestion_edits {
let old_end = old_snapshot let old_end = old_snapshot
.editor_addition_snapshot .inlay_snapshot
.to_point(suggestion_edit.old.end); .to_point(suggestion_edit.old.end);
let old_end_row_successor_offset = let old_end_row_successor_offset =
old_snapshot.editor_addition_snapshot.to_offset(cmp::min( old_snapshot.inlay_snapshot.to_offset(cmp::min(
EditorAdditionPoint::new(old_end.row() + 1, 0), InlayPoint::new(old_end.row() + 1, 0),
old_snapshot.editor_addition_snapshot.max_point(), old_snapshot.inlay_snapshot.max_point(),
)); ));
let new_end = new_snapshot let new_end = new_snapshot
.editor_addition_snapshot .inlay_snapshot
.to_point(suggestion_edit.new.end); .to_point(suggestion_edit.new.end);
let mut offset_from_edit = 0; let mut offset_from_edit = 0;
let mut first_tab_offset = None; let mut first_tab_offset = None;
let mut last_tab_with_changed_expansion_offset = None; let mut last_tab_with_changed_expansion_offset = None;
'outer: for chunk in old_snapshot.editor_addition_snapshot.chunks( 'outer: for chunk in old_snapshot.inlay_snapshot.chunks(
suggestion_edit.old.end..old_end_row_successor_offset, suggestion_edit.old.end..old_end_row_successor_offset,
false, false,
None, None,
@ -128,16 +126,16 @@ impl TabMap {
for suggestion_edit in suggestion_edits { for suggestion_edit in suggestion_edits {
let old_start = old_snapshot let old_start = old_snapshot
.editor_addition_snapshot .inlay_snapshot
.to_point(suggestion_edit.old.start); .to_point(suggestion_edit.old.start);
let old_end = old_snapshot let old_end = old_snapshot
.editor_addition_snapshot .inlay_snapshot
.to_point(suggestion_edit.old.end); .to_point(suggestion_edit.old.end);
let new_start = new_snapshot let new_start = new_snapshot
.editor_addition_snapshot .inlay_snapshot
.to_point(suggestion_edit.new.start); .to_point(suggestion_edit.new.start);
let new_end = new_snapshot let new_end = new_snapshot
.editor_addition_snapshot .inlay_snapshot
.to_point(suggestion_edit.new.end); .to_point(suggestion_edit.new.end);
tab_edits.push(TabEdit { tab_edits.push(TabEdit {
old: old_snapshot.to_tab_point(old_start)..old_snapshot.to_tab_point(old_end), old: old_snapshot.to_tab_point(old_start)..old_snapshot.to_tab_point(old_end),
@ -159,7 +157,7 @@ impl TabMap {
#[derive(Clone)] #[derive(Clone)]
pub struct TabSnapshot { pub struct TabSnapshot {
pub editor_addition_snapshot: EditorAdditionSnapshot, pub inlay_snapshot: InlaySnapshot,
pub tab_size: NonZeroU32, pub tab_size: NonZeroU32,
pub max_expansion_column: u32, pub max_expansion_column: u32,
pub version: usize, pub version: usize,
@ -167,15 +165,15 @@ pub struct TabSnapshot {
impl TabSnapshot { impl TabSnapshot {
pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot { pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot {
self.editor_addition_snapshot.buffer_snapshot() self.inlay_snapshot.buffer_snapshot()
} }
pub fn line_len(&self, row: u32) -> u32 { pub fn line_len(&self, row: u32) -> u32 {
let max_point = self.max_point(); let max_point = self.max_point();
if row < max_point.row() { if row < max_point.row() {
self.to_tab_point(EditorAdditionPoint::new( self.to_tab_point(InlayPoint::new(
row, row,
self.editor_addition_snapshot.line_len(row), self.inlay_snapshot.line_len(row),
)) ))
.0 .0
.column .column
@ -189,10 +187,10 @@ impl TabSnapshot {
} }
pub fn text_summary_for_range(&self, range: Range<TabPoint>) -> TextSummary { pub fn text_summary_for_range(&self, range: Range<TabPoint>) -> TextSummary {
let input_start = self.to_editor_addition_point(range.start, Bias::Left).0; let input_start = self.to_inlay_point(range.start, Bias::Left).0;
let input_end = self.to_editor_addition_point(range.end, Bias::Right).0; let input_end = self.to_inlay_point(range.end, Bias::Right).0;
let input_summary = self let input_summary = self
.editor_addition_snapshot .inlay_snapshot
.text_summary_for_range(input_start..input_end); .text_summary_for_range(input_start..input_end);
let mut first_line_chars = 0; let mut first_line_chars = 0;
@ -245,12 +243,12 @@ impl TabSnapshot {
suggestion_highlight: Option<HighlightStyle>, suggestion_highlight: Option<HighlightStyle>,
) -> TabChunks<'a> { ) -> TabChunks<'a> {
let (input_start, expanded_char_column, to_next_stop) = let (input_start, expanded_char_column, to_next_stop) =
self.to_editor_addition_point(range.start, Bias::Left); self.to_inlay_point(range.start, Bias::Left);
let input_column = input_start.column(); let input_column = input_start.column();
let input_start = self.editor_addition_snapshot.to_offset(input_start); let input_start = self.inlay_snapshot.to_offset(input_start);
let input_end = self let input_end = self
.editor_addition_snapshot .inlay_snapshot
.to_offset(self.to_editor_addition_point(range.end, Bias::Right).0); .to_offset(self.to_inlay_point(range.end, Bias::Right).0);
let to_next_stop = if range.start.0 + Point::new(0, to_next_stop) > range.end.0 { let to_next_stop = if range.start.0 + Point::new(0, to_next_stop) > range.end.0 {
range.end.column() - range.start.column() range.end.column() - range.start.column()
} else { } else {
@ -258,7 +256,7 @@ impl TabSnapshot {
}; };
TabChunks { TabChunks {
editor_addition_chunks: self.editor_addition_snapshot.chunks( inlay_chunks: self.inlay_snapshot.chunks(
input_start..input_end, input_start..input_end,
language_aware, language_aware,
text_highlights, text_highlights,
@ -279,8 +277,8 @@ impl TabSnapshot {
} }
} }
pub fn buffer_rows(&self, row: u32) -> editor_addition_map::EditorAdditionBufferRows<'_> { pub fn buffer_rows(&self, row: u32) -> inlay_map::InlayBufferRows<'_> {
self.editor_addition_snapshot.buffer_rows(row) self.inlay_snapshot.buffer_rows(row)
} }
#[cfg(test)] #[cfg(test)]
@ -291,37 +289,33 @@ impl TabSnapshot {
} }
pub fn max_point(&self) -> TabPoint { pub fn max_point(&self) -> TabPoint {
self.to_tab_point(self.editor_addition_snapshot.max_point()) self.to_tab_point(self.inlay_snapshot.max_point())
} }
pub fn clip_point(&self, point: TabPoint, bias: Bias) -> TabPoint { pub fn clip_point(&self, point: TabPoint, bias: Bias) -> TabPoint {
self.to_tab_point( self.to_tab_point(
self.editor_addition_snapshot self.inlay_snapshot
.clip_point(self.to_editor_addition_point(point, bias).0, bias), .clip_point(self.to_inlay_point(point, bias).0, bias),
) )
} }
pub fn to_tab_point(&self, input: EditorAdditionPoint) -> TabPoint { pub fn to_tab_point(&self, input: InlayPoint) -> TabPoint {
let chars = self let chars = self
.editor_addition_snapshot .inlay_snapshot
.chars_at(EditorAdditionPoint::new(input.row(), 0)); .chars_at(InlayPoint::new(input.row(), 0));
let expanded = self.expand_tabs(chars, input.column()); let expanded = self.expand_tabs(chars, input.column());
TabPoint::new(input.row(), expanded) TabPoint::new(input.row(), expanded)
} }
pub fn to_editor_addition_point( pub fn to_inlay_point(&self, output: TabPoint, bias: Bias) -> (InlayPoint, u32, u32) {
&self,
output: TabPoint,
bias: Bias,
) -> (EditorAdditionPoint, u32, u32) {
let chars = self let chars = self
.editor_addition_snapshot .inlay_snapshot
.chars_at(EditorAdditionPoint::new(output.row(), 0)); .chars_at(InlayPoint::new(output.row(), 0));
let expanded = output.column(); let expanded = output.column();
let (collapsed, expanded_char_column, to_next_stop) = let (collapsed, expanded_char_column, to_next_stop) =
self.collapse_tabs(chars, expanded, bias); self.collapse_tabs(chars, expanded, bias);
( (
EditorAdditionPoint::new(output.row(), collapsed as u32), InlayPoint::new(output.row(), collapsed as u32),
expanded_char_column, expanded_char_column,
to_next_stop, to_next_stop,
) )
@ -329,32 +323,32 @@ 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
.editor_addition_snapshot .inlay_snapshot
.suggestion_snapshot .suggestion_snapshot
.fold_snapshot .fold_snapshot
.to_fold_point(point, bias); .to_fold_point(point, bias);
let suggestion_point = self let suggestion_point = self
.editor_addition_snapshot .inlay_snapshot
.suggestion_snapshot .suggestion_snapshot
.to_suggestion_point(fold_point); .to_suggestion_point(fold_point);
let editor_addition_point = self let inlay_point = self
.editor_addition_snapshot .inlay_snapshot
.to_editor_addition_point(suggestion_point); .to_inlay_point(suggestion_point);
self.to_tab_point(editor_addition_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 editor_addition_point = self.to_editor_addition_point(point, bias).0; let inlay_point = self.to_inlay_point(point, bias).0;
let suggestion_point = self let suggestion_point = self
.editor_addition_snapshot .inlay_snapshot
.to_suggestion_point(editor_addition_point, bias); .to_suggestion_point(inlay_point, bias);
let fold_point = self let fold_point = self
.editor_addition_snapshot .inlay_snapshot
.suggestion_snapshot .suggestion_snapshot
.to_fold_point(suggestion_point); .to_fold_point(suggestion_point);
fold_point.to_buffer_point( fold_point.to_buffer_point(
&self &self
.editor_addition_snapshot .inlay_snapshot
.suggestion_snapshot .suggestion_snapshot
.fold_snapshot, .fold_snapshot,
) )
@ -516,7 +510,7 @@ impl<'a> std::ops::AddAssign<&'a Self> for TextSummary {
const SPACES: &str = " "; const SPACES: &str = " ";
pub struct TabChunks<'a> { pub struct TabChunks<'a> {
editor_addition_chunks: EditorAdditionChunks<'a>, inlay_chunks: InlayChunks<'a>,
chunk: Chunk<'a>, chunk: Chunk<'a>,
column: u32, column: u32,
max_expansion_column: u32, max_expansion_column: u32,
@ -532,7 +526,7 @@ impl<'a> Iterator for TabChunks<'a> {
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
if self.chunk.text.is_empty() { if self.chunk.text.is_empty() {
if let Some(chunk) = self.editor_addition_chunks.next() { if let Some(chunk) = self.inlay_chunks.next() {
self.chunk = chunk; self.chunk = chunk;
if self.inside_leading_tab { if self.inside_leading_tab {
self.chunk.text = &self.chunk.text[1..]; self.chunk.text = &self.chunk.text[1..];
@ -600,10 +594,7 @@ impl<'a> Iterator for TabChunks<'a> {
mod tests { mod tests {
use super::*; use super::*;
use crate::{ use crate::{
display_map::{ display_map::{fold_map::FoldMap, inlay_map::InlayMap, suggestion_map::SuggestionMap},
editor_addition_map::EditorAdditionMap, fold_map::FoldMap,
suggestion_map::SuggestionMap,
},
MultiBuffer, MultiBuffer,
}; };
use rand::{prelude::StdRng, Rng}; use rand::{prelude::StdRng, Rng};
@ -614,8 +605,8 @@ mod tests {
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 (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
let (_, editor_addition_snapshot) = EditorAdditionMap::new(suggestion_snapshot); let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, tab_snapshot) = TabMap::new(editor_addition_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);
assert_eq!(tab_snapshot.expand_tabs("\t".chars(), 1), 4); assert_eq!(tab_snapshot.expand_tabs("\t".chars(), 1), 4);
@ -632,8 +623,8 @@ mod tests {
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 (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
let (_, editor_addition_snapshot) = EditorAdditionMap::new(suggestion_snapshot); let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, mut tab_snapshot) = TabMap::new(editor_addition_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;
assert_eq!(tab_snapshot.text(), output); assert_eq!(tab_snapshot.text(), output);
@ -657,15 +648,15 @@ mod tests {
let input_point = Point::new(0, ix as u32); let input_point = Point::new(0, ix as u32);
let output_point = Point::new(0, output.find(c).unwrap() as u32); let output_point = Point::new(0, output.find(c).unwrap() as u32);
assert_eq!( assert_eq!(
tab_snapshot.to_tab_point(EditorAdditionPoint(input_point)), tab_snapshot.to_tab_point(InlayPoint(input_point)),
TabPoint(output_point), TabPoint(output_point),
"to_tab_point({input_point:?})" "to_tab_point({input_point:?})"
); );
assert_eq!( assert_eq!(
tab_snapshot tab_snapshot
.to_editor_addition_point(TabPoint(output_point), Bias::Left) .to_inlay_point(TabPoint(output_point), Bias::Left)
.0, .0,
EditorAdditionPoint(input_point), InlayPoint(input_point),
"to_suggestion_point({output_point:?})" "to_suggestion_point({output_point:?})"
); );
} }
@ -681,8 +672,8 @@ mod tests {
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 (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
let (_, editor_addition_snapshot) = EditorAdditionMap::new(suggestion_snapshot); let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, mut tab_snapshot) = TabMap::new(editor_addition_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;
assert_eq!(tab_snapshot.text(), input); assert_eq!(tab_snapshot.text(), input);
@ -696,8 +687,8 @@ mod tests {
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 (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
let (_, editor_addition_snapshot) = EditorAdditionMap::new(suggestion_snapshot); let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot);
let (_, tab_snapshot) = TabMap::new(editor_addition_snapshot, 4.try_into().unwrap()); let (_, tab_snapshot) = TabMap::new(inlay_snapshot, 4.try_into().unwrap());
assert_eq!( assert_eq!(
chunks(&tab_snapshot, TabPoint::zero()), chunks(&tab_snapshot, TabPoint::zero()),
@ -761,13 +752,10 @@ mod tests {
let (suggestion_map, _) = SuggestionMap::new(fold_snapshot); let (suggestion_map, _) = SuggestionMap::new(fold_snapshot);
let (suggestion_snapshot, _) = suggestion_map.randomly_mutate(&mut rng); let (suggestion_snapshot, _) = suggestion_map.randomly_mutate(&mut rng);
log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text()); log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
let (_, editor_addition_snapshot) = EditorAdditionMap::new(suggestion_snapshot.clone()); let (_, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone());
log::info!( log::info!("InlayMap text: {:?}", inlay_snapshot.text());
"EditorAdditionMap text: {:?}",
editor_addition_snapshot.text()
);
let (tab_map, _) = TabMap::new(editor_addition_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);
let text = text::Rope::from(tabs_snapshot.text().as_str()); let text = text::Rope::from(tabs_snapshot.text().as_str());
@ -805,7 +793,7 @@ mod tests {
); );
let mut actual_summary = tabs_snapshot.text_summary_for_range(start..end); let mut actual_summary = tabs_snapshot.text_summary_for_range(start..end);
if tab_size.get() > 1 && editor_addition_snapshot.text().contains('\t') { if tab_size.get() > 1 && inlay_snapshot.text().contains('\t') {
actual_summary.longest_row = expected_summary.longest_row; actual_summary.longest_row = expected_summary.longest_row;
actual_summary.longest_row_chars = expected_summary.longest_row_chars; actual_summary.longest_row_chars = expected_summary.longest_row_chars;
} }

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

@ -1,5 +1,5 @@
use super::{ use super::{
editor_addition_map::EditorAdditionBufferRows, inlay_map::InlayBufferRows,
tab_map::{self, TabEdit, TabPoint, TabSnapshot}, tab_map::{self, TabEdit, TabPoint, TabSnapshot},
TextHighlights, TextHighlights,
}; };
@ -65,7 +65,7 @@ pub struct WrapChunks<'a> {
#[derive(Clone)] #[derive(Clone)]
pub struct WrapBufferRows<'a> { pub struct WrapBufferRows<'a> {
input_buffer_rows: EditorAdditionBufferRows<'a>, input_buffer_rows: InlayBufferRows<'a>,
input_buffer_row: Option<u32>, input_buffer_row: Option<u32>,
output_row: u32, output_row: u32,
soft_wrapped: bool, soft_wrapped: bool,
@ -762,17 +762,17 @@ impl WrapSnapshot {
let mut prev_fold_row = 0; let mut prev_fold_row = 0;
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 editor_addition_point = self let inlay_point = self
.tab_snapshot .tab_snapshot
.to_editor_addition_point(tab_point, Bias::Left) .to_inlay_point(tab_point, Bias::Left)
.0; .0;
let suggestion_point = self let suggestion_point = self
.tab_snapshot .tab_snapshot
.editor_addition_snapshot .inlay_snapshot
.to_suggestion_point(editor_addition_point, Bias::Left); .to_suggestion_point(inlay_point, Bias::Left);
let fold_point = self let fold_point = self
.tab_snapshot .tab_snapshot
.editor_addition_snapshot .inlay_snapshot
.suggestion_snapshot .suggestion_snapshot
.to_fold_point(suggestion_point); .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 {
@ -781,7 +781,7 @@ impl WrapSnapshot {
let buffer_point = fold_point.to_buffer_point( let buffer_point = fold_point.to_buffer_point(
&self &self
.tab_snapshot .tab_snapshot
.editor_addition_snapshot .inlay_snapshot
.suggestion_snapshot .suggestion_snapshot
.fold_snapshot, .fold_snapshot,
); );
@ -1049,8 +1049,7 @@ mod tests {
use super::*; use super::*;
use crate::{ use crate::{
display_map::{ display_map::{
editor_addition_map::EditorAdditionMap, fold_map::FoldMap, fold_map::FoldMap, inlay_map::InlayMap, suggestion_map::SuggestionMap, tab_map::TabMap,
suggestion_map::SuggestionMap, tab_map::TabMap,
}, },
MultiBuffer, MultiBuffer,
}; };
@ -1106,13 +1105,9 @@ mod tests {
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 (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone());
log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text()); log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
let (editor_addition_map, editors_additions_snapshot) = let (inlay_map, inlay_snapshot) = InlayMap::new(suggestion_snapshot.clone());
EditorAdditionMap::new(suggestion_snapshot.clone()); log::info!("InlaysMap text: {:?}", inlay_snapshot.text());
log::info!( let (tab_map, _) = TabMap::new(inlay_snapshot.clone(), tab_size);
"EditorAdditionsMap text: {:?}",
editors_additions_snapshot.text()
);
let (tab_map, _) = TabMap::new(editors_additions_snapshot.clone(), tab_size);
let tabs_snapshot = tab_map.set_max_expansion_column(32); let tabs_snapshot = tab_map.set_max_expansion_column(32);
log::info!("TabMap text: {:?}", tabs_snapshot.text()); log::info!("TabMap text: {:?}", tabs_snapshot.text());
@ -1160,10 +1155,10 @@ mod tests {
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) = let (suggestion_snapshot, suggestion_edits) =
suggestion_map.sync(fold_snapshot, fold_edits); suggestion_map.sync(fold_snapshot, fold_edits);
let (editor_addition_snapshot, editor_addition_edits) = let (inlay_snapshot, inlay_edits) =
editor_addition_map.sync(suggestion_snapshot, suggestion_edits); inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tabs_snapshot, tab_edits) = let (tabs_snapshot, tab_edits) =
tab_map.sync(editor_addition_snapshot, editor_addition_edits, tab_size); tab_map.sync(inlay_snapshot, inlay_edits, tab_size);
let (mut snapshot, wrap_edits) = let (mut snapshot, wrap_edits) =
wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx)); wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
snapshot.check_invariants(); snapshot.check_invariants();
@ -1174,10 +1169,10 @@ mod tests {
40..=59 => { 40..=59 => {
let (suggestion_snapshot, suggestion_edits) = let (suggestion_snapshot, suggestion_edits) =
suggestion_map.randomly_mutate(&mut rng); suggestion_map.randomly_mutate(&mut rng);
let (editor_addition_snapshot, editor_addition_edits) = let (inlay_snapshot, inlay_edits) =
editor_addition_map.sync(suggestion_snapshot, suggestion_edits); inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tabs_snapshot, tab_edits) = let (tabs_snapshot, tab_edits) =
tab_map.sync(editor_addition_snapshot, editor_addition_edits, tab_size); tab_map.sync(inlay_snapshot, inlay_edits, tab_size);
let (mut snapshot, wrap_edits) = let (mut snapshot, wrap_edits) =
wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx)); wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
snapshot.check_invariants(); snapshot.check_invariants();
@ -1201,10 +1196,10 @@ mod tests {
let (suggestion_snapshot, suggestion_edits) = let (suggestion_snapshot, suggestion_edits) =
suggestion_map.sync(fold_snapshot, fold_edits); suggestion_map.sync(fold_snapshot, fold_edits);
log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text()); log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
let (editor_addition_snapshot, editor_addition_edits) = let (inlay_snapshot, inlay_edits) =
editor_addition_map.sync(suggestion_snapshot, suggestion_edits); inlay_map.sync(suggestion_snapshot, suggestion_edits);
let (tabs_snapshot, tab_edits) = let (tabs_snapshot, tab_edits) =
tab_map.sync(editor_addition_snapshot, editor_addition_edits, tab_size); tab_map.sync(inlay_snapshot, inlay_edits, tab_size);
log::info!("TabMap text: {:?}", tabs_snapshot.text()); log::info!("TabMap text: {:?}", tabs_snapshot.text());
let unwrapped_text = tabs_snapshot.text(); let unwrapped_text = tabs_snapshot.text();
@ -1252,7 +1247,7 @@ mod tests {
if tab_size.get() == 1 if tab_size.get() == 1
|| !wrapped_snapshot || !wrapped_snapshot
.tab_snapshot .tab_snapshot
.editor_addition_snapshot .inlay_snapshot
.text() .text()
.contains('\t') .contains('\t')
{ {