oak-team/oak-gpui
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP - maintain foldmap with Buffer::edits_since

Browse Source 
Co-Authored-By: Nathan Sobo <nathan@zed.dev>
This commit is contained in:
Max Brunsfeld
2021-11-30 17:23:02 -08:00
co-authored by Nathan Sobo
parent 2463077b2d
commit faba276fdc
11 changed files with 279 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/editor/src/display_map.rs
+45 -7
View File
@@ -1,6 +1,5 @@
mod block_map;
mod fold_map;
mod patch;
mod tab_map;
mod wrap_map;
@@ -11,9 +10,11 @@ use gpui::{
fonts::{FontId, HighlightStyle},
AppContext, Entity, ModelContext, ModelHandle,
};
use language::{Anchor, Buffer, Point, ToOffset, ToPoint};
use language::{Anchor, Buffer, Patch, Point, ToOffset, ToPoint};
use parking_lot::Mutex;
use std::{
collections::{HashMap, HashSet},
mem,
ops::Range,
};
use sum_tree::Bias;
@@ -32,6 +33,7 @@ pub struct DisplayMap {
tab_map: TabMap,
wrap_map: ModelHandle<WrapMap>,
block_map: BlockMap,
edits_since_sync: Mutex<Patch<usize>>,
}
impl Entity for DisplayMap {
@@ -52,17 +54,22 @@ impl DisplayMap {
let (wrap_map, snapshot) = WrapMap::new(snapshot, font_id, font_size, wrap_width, cx);
let block_map = BlockMap::new(buffer.clone(), snapshot);
cx.observe(&wrap_map, |_, _, cx| cx.notify()).detach();
cx.subscribe(&buffer, Self::handle_buffer_event).detach();
DisplayMap {
buffer,
fold_map,
tab_map,
wrap_map,
block_map,
edits_since_sync: Default::default(),
}
}
pub fn snapshot(&self, cx: &mut ModelContext<Self>) -> DisplayMapSnapshot {
let (folds_snapshot, edits) = self.fold_map.read(cx);
let (folds_snapshot, edits) = self.fold_map.read(
mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
cx,
);
let (tabs_snapshot, edits) = self.tab_map.sync(folds_snapshot.clone(), edits);
let (wraps_snapshot, edits) = self
.wrap_map
@@ -83,7 +90,10 @@ impl DisplayMap {
ranges: impl IntoIterator<Item = Range<T>>,
cx: &mut ModelContext<Self>,
) {
let (mut fold_map, snapshot, edits) = self.fold_map.write(cx);
let (mut fold_map, snapshot, edits) = self.fold_map.write(
mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
cx,
);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
let (snapshot, edits) = self
.wrap_map
@@ -102,7 +112,10 @@ impl DisplayMap {
ranges: impl IntoIterator<Item = Range<T>>,
cx: &mut ModelContext<Self>,
) {
let (mut fold_map, snapshot, edits) = self.fold_map.write(cx);
let (mut fold_map, snapshot, edits) = self.fold_map.write(
mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
cx,
);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
let (snapshot, edits) = self
.wrap_map
@@ -125,7 +138,10 @@ impl DisplayMap {
P: ToOffset + Clone,
T: Into<Rope> + Clone,
{
let (snapshot, edits) = self.fold_map.read(cx);
let (snapshot, edits) = self.fold_map.read(
mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
cx,
);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
let (snapshot, edits) = self
.wrap_map
@@ -143,7 +159,10 @@ impl DisplayMap {
}
pub fn remove_blocks(&mut self, ids: HashSet<BlockId>, cx: &mut ModelContext<Self>) {
let (snapshot, edits) = self.fold_map.read(cx);
let (snapshot, edits) = self.fold_map.read(
mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
cx,
);
let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
let (snapshot, edits) = self
.wrap_map
@@ -166,6 +185,25 @@ impl DisplayMap {
pub fn is_rewrapping(&self, cx: &gpui::AppContext) -> bool {
self.wrap_map.read(cx).is_rewrapping()
}
fn handle_buffer_event(
&mut self,
_: ModelHandle<Buffer>,
event: &language::Event,
_: &mut ModelContext<Self>,
) {
match event {
language::Event::Edited(patch) => {
self.fold_map.version += 1;
let mut edits_since_sync = self.edits_since_sync.lock();
*edits_since_sync = edits_since_sync.compose(patch);
}
language::Event::Reparsed | language::Event::DiagnosticsUpdated => {
self.fold_map.version += 1;
}
_ => {}
}
}
}
pub struct DisplayMapSnapshot {
crates/editor/src/display_map/block_map.rs
+11 -6
View File
@@ -1228,11 +1228,13 @@ mod tests {
// Insert a line break, separating two block decorations into separate
// lines.
buffer.update(cx, |buffer, cx| {
buffer.edit([Point::new(1, 1)..Point::new(1, 1)], "!!!\n", cx)
let buffer_edits = buffer.update(cx, |buffer, cx| {
let v0 = buffer.version();
buffer.edit([Point::new(1, 1)..Point::new(1, 1)], "!!!\n", cx);
buffer.edits_since(&v0).collect()
});
let (folds_snapshot, fold_edits) = fold_map.read(cx);
let (folds_snapshot, fold_edits) = fold_map.read(buffer_edits, cx);
let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tabs_snapshot, tab_edits, cx)
@@ -1325,6 +1327,7 @@ mod tests {
let mut expected_blocks = Vec::new();
for _ in 0..operations {
let mut buffer_edits = Vec::new();
match rng.gen_range(0..=100) {
0..=19 => {
let wrap_width = if rng.gen_bool(0.2) {
@@ -1375,7 +1378,7 @@ mod tests {
})
.collect::<Vec<_>>();
let (folds_snapshot, fold_edits) = fold_map.read(cx);
let (folds_snapshot, fold_edits) = fold_map.read(vec![], cx);
let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tabs_snapshot, tab_edits, cx)
@@ -1396,7 +1399,7 @@ mod tests {
})
.collect();
let (folds_snapshot, fold_edits) = fold_map.read(cx);
let (folds_snapshot, fold_edits) = fold_map.read(vec![], cx);
let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tabs_snapshot, tab_edits, cx)
@@ -1406,13 +1409,15 @@ mod tests {
}
_ => {
buffer.update(cx, |buffer, _| {
let v0 = buffer.version();
buffer.randomly_edit(&mut rng, 1);
log::info!("buffer text: {:?}", buffer.text());
buffer_edits.extend(buffer.edits_since(&v0));
});
}
}
let (folds_snapshot, fold_edits) = fold_map.read(cx);
let (folds_snapshot, fold_edits) = fold_map.read(buffer_edits, cx);
let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tabs_snapshot, tab_edits, cx)
crates/editor/src/display_map/fold_map.rs
+81 -102
View File
@@ -1,11 +1,12 @@
use gpui::{AppContext, ModelHandle};
use language::{Anchor, AnchorRangeExt, Buffer, Chunk, Point, PointUtf16, TextSummary, ToOffset};
use language::{
Anchor, AnchorRangeExt, Buffer, Chunk, Edit, Point, PointUtf16, TextSummary, ToOffset,
};
use parking_lot::Mutex;
use std::{
cmp::{self, Ordering},
iter, mem,
iter,
ops::Range,
sync::atomic::{AtomicUsize, Ordering::SeqCst},
};
use sum_tree::{Bias, Cursor, FilterCursor, SumTree};
use theme::SyntaxTheme;
@@ -131,12 +132,12 @@ impl<'a> FoldMapWriter<'a> {
};
consolidate_buffer_edits(&mut edits);
let edits = self.0.apply_edits(edits, cx);
let edits = self.0.sync(edits, cx);
let snapshot = Snapshot {
transforms: self.0.transforms.lock().clone(),
folds: self.0.folds.clone(),
buffer_snapshot: self.0.buffer.read(cx).snapshot(),
version: self.0.version.load(SeqCst),
version: self.0.version,
};
(snapshot, edits)
}
@@ -150,7 +151,7 @@ impl<'a> FoldMapWriter<'a> {
let mut fold_ixs_to_delete = Vec::new();
let buffer = self.0.buffer.read(cx).snapshot();
for range in ranges.into_iter() {
// Remove intersecting folds and add their ranges to edits that are passed to apply_edits.
// Remove intersecting folds and add their ranges to edits that are passed to sync.
let mut folds_cursor = intersecting_folds(&buffer, &self.0.folds, range, true);
while let Some(fold) = folds_cursor.item() {
let offset_range = fold.0.start.to_offset(&buffer)..fold.0.end.to_offset(&buffer);
@@ -178,12 +179,12 @@ impl<'a> FoldMapWriter<'a> {
};
consolidate_buffer_edits(&mut edits);
let edits = self.0.apply_edits(edits, cx);
let edits = self.0.sync(edits, cx);
let snapshot = Snapshot {
transforms: self.0.transforms.lock().clone(),
folds: self.0.folds.clone(),
buffer_snapshot: self.0.buffer.read(cx).snapshot(),
version: self.0.version.load(SeqCst),
version: self.0.version,
};
(snapshot, edits)
}
@@ -193,15 +194,7 @@ pub struct FoldMap {
buffer: ModelHandle<Buffer>,
transforms: Mutex<SumTree<Transform>>,
folds: SumTree<Fold>,
last_sync: Mutex<SyncState>,
version: AtomicUsize,
}
#[derive(Clone)]
struct SyncState {
version: clock::Global,
parse_count: usize,
diagnostics_update_count: usize,
pub version: usize,
}
impl FoldMap {
@@ -220,60 +213,33 @@ impl FoldMap {
},
&(),
)),
last_sync: Mutex::new(SyncState {
version: buffer.version(),
parse_count: buffer.parse_count(),
diagnostics_update_count: buffer.diagnostics_update_count(),
}),
version: AtomicUsize::new(0),
version: 0,
};
let (snapshot, _) = this.read(cx);
let (snapshot, _) = this.read(Vec::new(), cx);
(this, snapshot)
}
pub fn read(&self, cx: &AppContext) -> (Snapshot, Vec<FoldEdit>) {
let edits = self.sync(cx);
pub fn read(&self, edits: Vec<Edit<usize>>, cx: &AppContext) -> (Snapshot, Vec<FoldEdit>) {
let edits = self.sync(edits, cx);
self.check_invariants(cx);
let snapshot = Snapshot {
transforms: self.transforms.lock().clone(),
folds: self.folds.clone(),
buffer_snapshot: self.buffer.read(cx).snapshot(),
version: self.version.load(SeqCst),
version: self.version,
};
(snapshot, edits)
}
pub fn write(&mut self, cx: &AppContext) -> (FoldMapWriter, Snapshot, Vec<FoldEdit>) {
let (snapshot, edits) = self.read(cx);
pub fn write(
&mut self,
edits: Vec<Edit<usize>>,
cx: &AppContext,
) -> (FoldMapWriter, Snapshot, Vec<FoldEdit>) {
let (snapshot, edits) = self.read(edits, cx);
(FoldMapWriter(self), snapshot, edits)
}
fn sync(&self, cx: &AppContext) -> Vec<FoldEdit> {
let buffer = self.buffer.read(cx);
let last_sync = mem::replace(
&mut *self.last_sync.lock(),
SyncState {
version: buffer.version(),
parse_count: buffer.parse_count(),
diagnostics_update_count: buffer.diagnostics_update_count(),
},
);
let edits = buffer
.edits_since(&last_sync.version)
.map(Into::into)
.collect::<Vec<_>>();
if edits.is_empty() {
if last_sync.parse_count != buffer.parse_count()
|| last_sync.diagnostics_update_count != buffer.diagnostics_update_count()
{
self.version.fetch_add(1, SeqCst);
}
Vec::new()
} else {
self.apply_edits(edits, cx)
}
}
fn check_invariants(&self, cx: &AppContext) {
if cfg!(test) {
let buffer = self.buffer.read(cx);
@@ -285,7 +251,11 @@ impl FoldMap {
}
}
fn apply_edits(&self, buffer_edits: Vec<text::Edit<usize>>, cx: &AppContext) -> Vec<FoldEdit> {
fn sync(&self, buffer_edits: Vec<text::Edit<usize>>, cx: &AppContext) -> Vec<FoldEdit> {
if buffer_edits.is_empty() {
return Vec::new();
}
let buffer = self.buffer.read(cx).snapshot();
let mut buffer_edits_iter = buffer_edits.iter().cloned().peekable();
@@ -479,7 +449,6 @@ impl FoldMap {
}
*transforms = new_transforms;
self.version.fetch_add(1, SeqCst);
fold_edits
}
}
@@ -1086,7 +1055,7 @@ mod tests {
let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
let (snapshot2, edits) = writer.fold(
vec![
Point::new(0, 2)..Point::new(2, 2),
@@ -1109,7 +1078,8 @@ mod tests {
]
);
buffer.update(cx, |buffer, cx| {
let edits = buffer.update(cx, |buffer, cx| {
let v0 = buffer.version();
buffer.edit(
vec![
Point::new(0, 0)..Point::new(0, 1),
@@ -1118,8 +1088,9 @@ mod tests {
"123",
cx,
);
buffer.edits_since(&v0).collect()
});
let (snapshot3, edits) = map.read(cx.as_ref());
let (snapshot3, edits) = map.read(edits, cx.as_ref());
assert_eq!(snapshot3.text(), "123a…c123c…eeeee");
assert_eq!(
edits,
@@ -1135,15 +1106,17 @@ mod tests {
]
);
buffer.update(cx, |buffer, cx| {
buffer.edit(vec![Point::new(2, 6)..Point::new(4, 3)], "456", cx)
let edits = buffer.update(cx, |buffer, cx| {
let v0 = buffer.version();
buffer.edit(vec![Point::new(2, 6)..Point::new(4, 3)], "456", cx);
buffer.edits_since(&v0).collect()
});
let (snapshot4, _) = map.read(cx.as_ref());
let (snapshot4, _) = map.read(edits, cx.as_ref());
assert_eq!(snapshot4.text(), "123a…c123456eee");
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.unfold(Some(Point::new(0, 4)..Point::new(0, 5)), cx.as_ref());
let (snapshot5, _) = map.read(cx.as_ref());
let (snapshot5, _) = map.read(vec![], cx.as_ref());
assert_eq!(snapshot5.text(), "123aaaaa\nbbbbbb\nccc123456eee");
}
@@ -1154,21 +1127,21 @@ mod tests {
{
let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.fold(vec![5..8], cx.as_ref());
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(vec![], cx.as_ref());
assert_eq!(snapshot.text(), "abcde…ijkl");
// Create an fold adjacent to the start of the first fold.
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.fold(vec![0..1, 2..5], cx.as_ref());
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(vec![], cx.as_ref());
assert_eq!(snapshot.text(), "…b…ijkl");
// Create an fold adjacent to the end of the first fold.
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.fold(vec![11..11, 8..10], cx.as_ref());
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(vec![], cx.as_ref());
assert_eq!(snapshot.text(), "…b…kl");
}
@@ -1176,14 +1149,18 @@ mod tests {
let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
// Create two adjacent folds.
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.fold(vec![0..2, 2..5], cx.as_ref());
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(vec![], cx.as_ref());
assert_eq!(snapshot.text(), "…fghijkl");
// Edit within one of the folds.
buffer.update(cx, |buffer, cx| buffer.edit(vec![0..1], "12345", cx));
let (snapshot, _) = map.read(cx.as_ref());
let edits = buffer.update(cx, |buffer, cx| {
let v0 = buffer.version();
buffer.edit(vec![0..1], "12345", cx);
buffer.edits_since(&v0).collect()
});
let (snapshot, _) = map.read(edits, cx.as_ref());
assert_eq!(snapshot.text(), "12345…fghijkl");
}
}
@@ -1192,7 +1169,7 @@ mod tests {
fn test_overlapping_folds(cx: &mut gpui::MutableAppContext) {
let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.fold(
vec![
Point::new(0, 2)..Point::new(2, 2),
@@ -1202,7 +1179,7 @@ mod tests {
],
cx.as_ref(),
);
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(vec![], cx.as_ref());
assert_eq!(snapshot.text(), "aa…eeeee");
}
@@ -1211,7 +1188,7 @@ mod tests {
let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.fold(
vec![
Point::new(0, 2)..Point::new(2, 2),
@@ -1219,13 +1196,15 @@ mod tests {
],
cx.as_ref(),
);
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(vec![], cx.as_ref());
assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee");
buffer.update(cx, |buffer, cx| {
buffer.edit(Some(Point::new(2, 2)..Point::new(3, 1)), "", cx)
let edits = buffer.update(cx, |buffer, cx| {
let v0 = buffer.version();
buffer.edit(Some(Point::new(2, 2)..Point::new(3, 1)), "", cx);
buffer.edits_since(&v0).collect()
});
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(edits, cx.as_ref());
assert_eq!(snapshot.text(), "aa…eeeee");
}
@@ -1235,7 +1214,7 @@ mod tests {
let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
let buffer = buffer.read(cx);
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.fold(
vec![
Point::new(0, 2)..Point::new(2, 2),
@@ -1245,7 +1224,7 @@ mod tests {
],
cx.as_ref(),
);
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(vec![], cx.as_ref());
let fold_ranges = snapshot
.folds_in_range(Point::new(1, 0)..Point::new(1, 3))
.map(|fold| fold.start.to_point(buffer)..fold.end.to_point(buffer))
@@ -1272,27 +1251,27 @@ mod tests {
});
let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
let (mut initial_snapshot, _) = map.read(cx.as_ref());
let (mut initial_snapshot, _) = map.read(vec![], cx.as_ref());
let mut snapshot_edits = Vec::new();
for _ in 0..operations {
log::info!("text: {:?}", buffer.read(cx).text());
match rng.gen_range(0..=100) {
let buffer_edits = match rng.gen_range(0..=100) {
0..=59 => {
snapshot_edits.extend(map.randomly_mutate(&mut rng, cx.as_ref()));
vec![]
}
_ => {
let edits = buffer.update(cx, |buffer, _| {
let start_version = buffer.version.clone();
let edit_count = rng.gen_range(1..=5);
buffer.randomly_edit(&mut rng, edit_count);
buffer
.edits_since::<Point>(&start_version)
.collect::<Vec<_>>()
});
_ => buffer.update(cx, |buffer, _| {
let start_version = buffer.version.clone();
let edit_count = rng.gen_range(1..=5);
buffer.randomly_edit(&mut rng, edit_count);
let edits = buffer
.edits_since::<Point>(&start_version)
.collect::<Vec<_>>();
log::info!("editing {:?}", edits);
}
}
buffer.edits_since::<usize>(&start_version).collect()
}),
};
let buffer = map.buffer.read(cx).snapshot();
let mut expected_text: String = buffer.text().to_string();
@@ -1309,7 +1288,7 @@ mod tests {
expected_buffer_rows.extend((0..=next_row).rev());
expected_buffer_rows.reverse();
let (snapshot, edits) = map.read(cx.as_ref());
let (snapshot, edits) = map.read(buffer_edits, cx.as_ref());
assert_eq!(snapshot.text(), expected_text);
snapshot_edits.push((snapshot.clone(), edits));
@@ -1479,7 +1458,7 @@ mod tests {
let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
let (mut writer, _, _) = map.write(cx.as_ref());
let (mut writer, _, _) = map.write(vec![], cx.as_ref());
writer.fold(
vec![
Point::new(0, 2)..Point::new(2, 2),
@@ -1488,7 +1467,7 @@ mod tests {
cx.as_ref(),
);
let (snapshot, _) = map.read(cx.as_ref());
let (snapshot, _) = map.read(vec![], cx.as_ref());
assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee\nffffff\n");
assert_eq!(snapshot.buffer_rows(0).collect::<Vec<_>>(), [0, 3, 5, 6]);
assert_eq!(snapshot.buffer_rows(3).collect::<Vec<_>>(), [6]);
@@ -1540,7 +1519,7 @@ mod tests {
to_unfold.push(start..end);
}
log::info!("unfolding {:?}", to_unfold);
let (mut writer, snapshot, edits) = self.write(cx.as_ref());
let (mut writer, snapshot, edits) = self.write(vec![], cx.as_ref());
snapshot_edits.push((snapshot, edits));
let (snapshot, edits) = writer.fold(to_unfold, cx.as_ref());
snapshot_edits.push((snapshot, edits));
@@ -1554,7 +1533,7 @@ mod tests {
to_fold.push(start..end);
}
log::info!("folding {:?}", to_fold);
let (mut writer, snapshot, edits) = self.write(cx.as_ref());
let (mut writer, snapshot, edits) = self.write(vec![], cx.as_ref());
snapshot_edits.push((snapshot, edits));
let (snapshot, edits) = writer.fold(to_fold, cx.as_ref());
snapshot_edits.push((snapshot, edits));
crates/editor/src/display_map/patch.rs
-511
View File
@@ -1,511 +0,0 @@
use std::{cmp, mem};
type Edit = text::Edit<u32>;
#[derive(Default, Debug, PartialEq, Eq)]
pub struct Patch(Vec<Edit>);
impl Patch {
pub unsafe fn new_unchecked(edits: Vec<Edit>) -> Self {
Self(edits)
}
pub fn into_inner(self) -> Vec<Edit> {
self.0
}
pub fn compose(&self, other: &Self) -> Self {
let mut old_edits_iter = self.0.iter().cloned().peekable();
let mut new_edits_iter = other.0.iter().cloned().peekable();
let mut composed = Patch(Vec::new());
let mut old_start = 0;
let mut new_start = 0;
loop {
let old_edit = old_edits_iter.peek_mut();
let new_edit = new_edits_iter.peek_mut();
// Push the old edit if its new end is before the new edit's old start.
if let Some(old_edit) = old_edit.as_ref() {
let new_edit = new_edit.as_ref();
if new_edit.map_or(true, |new_edit| old_edit.new.end < new_edit.old.start) {
let catchup = old_edit.old.start - old_start;
old_start += catchup;
new_start += catchup;
let old_end = old_start + old_edit.old.len() as u32;
let new_end = new_start + old_edit.new.len() as u32;
composed.push(Edit {
old: old_start..old_end,
new: new_start..new_end,
});
old_start = old_end;
new_start = new_end;
old_edits_iter.next();
continue;
}
}
// Push the new edit if its old end is before the old edit's new start.
if let Some(new_edit) = new_edit.as_ref() {
let old_edit = old_edit.as_ref();
if old_edit.map_or(true, |old_edit| new_edit.old.end < old_edit.new.start) {
let catchup = new_edit.new.start - new_start;
old_start += catchup;
new_start += catchup;
let old_end = old_start + new_edit.old.len() as u32;
let new_end = new_start + new_edit.new.len() as u32;
composed.push(Edit {
old: old_start..old_end,
new: new_start..new_end,
});
old_start = old_end;
new_start = new_end;
new_edits_iter.next();
continue;
}
}
// If we still have edits by this point then they must intersect, so we compose them.
if let Some((old_edit, new_edit)) = old_edit.zip(new_edit) {
if old_edit.new.start < new_edit.old.start {
let catchup = old_edit.old.start - old_start;
old_start += catchup;
new_start += catchup;
let overshoot = new_edit.old.start - old_edit.new.start;
let old_end = cmp::min(old_start + overshoot, old_edit.old.end);
let new_end = new_start + overshoot;
composed.push(Edit {
old: old_start..old_end,
new: new_start..new_end,
});
old_edit.old.start += overshoot;
old_edit.new.start += overshoot;
old_start = old_end;
new_start = new_end;
} else {
let catchup = new_edit.new.start - new_start;
old_start += catchup;
new_start += catchup;
let overshoot = old_edit.new.start - new_edit.old.start;
let old_end = old_start + overshoot;
let new_end = cmp::min(new_start + overshoot, new_edit.new.end);
composed.push(Edit {
old: old_start..old_end,
new: new_start..new_end,
});
new_edit.old.start += overshoot;
new_edit.new.start += overshoot;
old_start = old_end;
new_start = new_end;
}
if old_edit.new.end > new_edit.old.end {
let old_end =
old_start + cmp::min(old_edit.old.len() as u32, new_edit.old.len() as u32);
let new_end = new_start + new_edit.new.len() as u32;
composed.push(Edit {
old: old_start..old_end,
new: new_start..new_end,
});
old_edit.old.start = old_end;
old_edit.new.start = new_edit.old.end;
old_start = old_end;
new_start = new_end;
new_edits_iter.next();
} else {
let old_end = old_start + old_edit.old.len() as u32;
let new_end =
new_start + cmp::min(old_edit.new.len() as u32, new_edit.new.len() as u32);
composed.push(Edit {
old: old_start..old_end,
new: new_start..new_end,
});
new_edit.old.start = old_edit.new.end;
new_edit.new.start = new_end;
old_start = old_end;
new_start = new_end;
old_edits_iter.next();
}
} else {
break;
}
}
composed
}
pub fn invert(&mut self) -> &mut Self {
for edit in &mut self.0 {
mem::swap(&mut edit.old, &mut edit.new);
}
self
}
pub fn clear(&mut self) {
self.0.clear();
}
fn push(&mut self, edit: Edit) {
if edit.old.len() == 0 && edit.new.len() == 0 {
return;
}
if let Some(last) = self.0.last_mut() {
if last.old.end >= edit.old.start {
last.old.end = edit.old.end;
last.new.end = edit.new.end;
} else {
self.0.push(edit);
}
} else {
self.0.push(edit);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use rand::prelude::*;
use std::env;
#[gpui::test]
fn test_one_disjoint_edit() {
assert_patch_composition(
Patch(vec![Edit {
old: 1..3,
new: 1..4,
}]),
Patch(vec![Edit {
old: 0..0,
new: 0..4,
}]),
Patch(vec![
Edit {
old: 0..0,
new: 0..4,
},
Edit {
old: 1..3,
new: 5..8,
},
]),
);
assert_patch_composition(
Patch(vec![Edit {
old: 1..3,
new: 1..4,
}]),
Patch(vec![Edit {
old: 5..9,
new: 5..7,
}]),
Patch(vec![
Edit {
old: 1..3,
new: 1..4,
},
Edit {
old: 4..8,
new: 5..7,
},
]),
);
}
#[gpui::test]
fn test_one_overlapping_edit() {
assert_patch_composition(
Patch(vec![Edit {
old: 1..3,
new: 1..4,
}]),
Patch(vec![Edit {
old: 3..5,
new: 3..6,
}]),
Patch(vec![Edit {
old: 1..4,
new: 1..6,
}]),
);
}
#[gpui::test]
fn test_two_disjoint_and_overlapping() {
assert_patch_composition(
Patch(vec![
Edit {
old: 1..3,
new: 1..4,
},
Edit {
old: 8..12,
new: 9..11,
},
]),
Patch(vec![
Edit {
old: 0..0,
new: 0..4,
},
Edit {
old: 3..10,
new: 7..9,
},
]),
Patch(vec![
Edit {
old: 0..0,
new: 0..4,
},
Edit {
old: 1..12,
new: 5..10,
},
]),
);
}
#[gpui::test]
fn test_two_new_edits_overlapping_one_old_edit() {
assert_patch_composition(
Patch(vec![Edit {
old: 0..0,
new: 0..3,
}]),
Patch(vec![
Edit {
old: 0..0,
new: 0..1,
},
Edit {
old: 1..2,
new: 2..2,
},
]),
Patch(vec![Edit {
old: 0..0,
new: 0..3,
}]),
);
assert_patch_composition(
Patch(vec![Edit {
old: 2..3,
new: 2..4,
}]),
Patch(vec![
Edit {
old: 0..2,
new: 0..1,
},
Edit {
old: 3..3,
new: 2..5,
},
]),
Patch(vec![Edit {
old: 0..3,
new: 0..6,
}]),
);
assert_patch_composition(
Patch(vec![Edit {
old: 0..0,
new: 0..2,
}]),
Patch(vec![
Edit {
old: 0..0,
new: 0..2,
},
Edit {
old: 2..5,
new: 4..4,
},
]),
Patch(vec![Edit {
old: 0..3,
new: 0..4,
}]),
);
}
// #[test]
// fn test_compose_edits() {
// assert_eq!(
// compose_edits(
// &Edit {
// old: 3..3,
// new: 3..6,
// },
// &Edit {
// old: 2..7,
// new: 2..4,
// },
// ),
// Edit {
// old: 2..4,
// new: 2..4
// }
// );
// }
#[gpui::test]
fn test_two_new_edits_touching_one_old_edit() {
assert_patch_composition(
Patch(vec![
Edit {
old: 2..3,
new: 2..4,
},
Edit {
old: 7..7,
new: 8..11,
},
]),
Patch(vec![
Edit {
old: 2..3,
new: 2..2,
},
Edit {
old: 4..4,
new: 3..4,
},
]),
Patch(vec![
Edit {
old: 2..3,
new: 2..4,
},
Edit {
old: 7..7,
new: 8..11,
},
]),
);
}
#[gpui::test(iterations = 100)]
fn test_random_patch_compositions(mut rng: StdRng) {
let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
.unwrap_or(20);
let initial_chars = (0..rng.gen_range(0..=100))
.map(|_| rng.gen_range(b'a'..=b'z') as char)
.collect::<Vec<_>>();
log::info!("initial chars: {:?}", initial_chars);
// Generate two sequential patches
let mut patches = Vec::new();
let mut expected_chars = initial_chars.clone();
for i in 0..2 {
log::info!("patch {}:", i);
let mut delta = 0i32;
let mut last_edit_end = 0;
let mut edits = Vec::new();
for _ in 0..operations {
if last_edit_end >= expected_chars.len() {
break;
}
let end = rng.gen_range(last_edit_end..=expected_chars.len());
let start = rng.gen_range(last_edit_end..=end);
let old_len = end - start;
let mut new_len = rng.gen_range(0..=3);
if start == end && new_len == 0 {
new_len += 1;
}
last_edit_end = start + new_len + 1;
let new_chars = (0..new_len)
.map(|_| rng.gen_range(b'A'..=b'Z') as char)
.collect::<Vec<_>>();
log::info!(
" editing {:?}: {:?}",
start..end,
new_chars.iter().collect::<String>()
);
edits.push(Edit {
old: (start as i32 - delta) as u32..(end as i32 - delta) as u32,
new: start as u32..(start + new_len) as u32,
});
expected_chars.splice(start..end, new_chars);
delta += new_len as i32 - old_len as i32;
}
patches.push(Patch(edits));
}
log::info!("old patch: {:?}", &patches[0]);
log::info!("new patch: {:?}", &patches[1]);
log::info!("initial chars: {:?}", initial_chars);
log::info!("final chars: {:?}", expected_chars);
// Compose the patches, and verify that it has the same effect as applying the
// two patches separately.
let composed = patches[0].compose(&patches[1]);
log::info!("composed patch: {:?}", &composed);
let mut actual_chars = initial_chars.clone();
for edit in composed.0 {
actual_chars.splice(
edit.new.start as usize..edit.new.start as usize + edit.old.len(),
expected_chars[edit.new.start as usize..edit.new.end as usize]
.iter()
.copied(),
);
}
assert_eq!(actual_chars, expected_chars);
}
#[track_caller]
fn assert_patch_composition(old: Patch, new: Patch, composed: Patch) {
let original = ('a'..'z').collect::<Vec<_>>();
let inserted = ('A'..'Z').collect::<Vec<_>>();
let mut expected = original.clone();
apply_patch(&mut expected, &old, &inserted);
apply_patch(&mut expected, &new, &inserted);
let mut actual = original.clone();
apply_patch(&mut actual, &composed, &expected);
assert_eq!(
actual.into_iter().collect::<String>(),
expected.into_iter().collect::<String>(),
"expected patch is incorrect"
);
assert_eq!(old.compose(&new), composed);
}
fn apply_patch(text: &mut Vec<char>, patch: &Patch, new_text: &[char]) {
for edit in patch.0.iter().rev() {
text.splice(
edit.old.start as usize..edit.old.end as usize,
new_text[edit.new.start as usize..edit.new.end as usize]
.iter()
.copied(),
);
}
}
}
crates/editor/src/display_map/tab_map.rs
+1 -1
View File
@@ -474,7 +474,7 @@ mod tests {
let (mut fold_map, _) = FoldMap::new(buffer.clone(), cx);
fold_map.randomly_mutate(&mut rng, cx);
let (folds_snapshot, _) = fold_map.read(cx);
let (folds_snapshot, _) = fold_map.read(vec![], cx);
log::info!("FoldMap text: {:?}", folds_snapshot.text());
let (_, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
crates/editor/src/display_map/wrap_map.rs
+13 -8
View File
@@ -1,6 +1,5 @@
use super::{
fold_map,
patch::Patch,
tab_map::{self, Edit as TabEdit, Snapshot as TabSnapshot, TabPoint},
DisplayRow,
};
@@ -13,6 +12,7 @@ use lazy_static::lazy_static;
use smol::future::yield_now;
use std::{collections::VecDeque, mem, ops::Range, time::Duration};
use sum_tree::{Bias, Cursor, SumTree};
use text::Patch;
use theme::SyntaxTheme;
pub use super::tab_map::TextSummary;
@@ -21,8 +21,8 @@ pub type Edit = text::Edit<u32>;
pub struct WrapMap {
snapshot: Snapshot,
pending_edits: VecDeque<(TabSnapshot, Vec<TabEdit>)>,
interpolated_edits: Patch,
edits_since_sync: Patch,
interpolated_edits: Patch<u32>,
edits_since_sync: Patch<u32>,
wrap_width: Option<f32>,
background_task: Option<Task<()>>,
font: (FontId, f32),
@@ -308,7 +308,7 @@ impl Snapshot {
}
}
fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, tab_edits: &[TabEdit]) -> Patch {
fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, tab_edits: &[TabEdit]) -> Patch<u32> {
let mut new_transforms;
if tab_edits.is_empty() {
new_transforms = self.transforms.clone();
@@ -383,7 +383,7 @@ impl Snapshot {
tab_edits: &[TabEdit],
wrap_width: f32,
line_wrapper: &mut LineWrapper,
) -> Patch {
) -> Patch<u32> {
#[derive(Debug)]
struct RowEdit {
old_rows: Range<u32>,
@@ -526,7 +526,7 @@ impl Snapshot {
old_snapshot.compute_edits(tab_edits, self)
}
fn compute_edits(&self, tab_edits: &[TabEdit], new_snapshot: &Snapshot) -> Patch {
fn compute_edits(&self, tab_edits: &[TabEdit], new_snapshot: &Snapshot) -> Patch<u32> {
let mut wrap_edits = Vec::new();
let mut old_cursor = self.transforms.cursor::<TransformSummary>();
let mut new_cursor = new_snapshot.transforms.cursor::<TransformSummary>();
@@ -1067,6 +1067,7 @@ mod tests {
for _i in 0..operations {
log::info!("{} ==============================================", _i);
let mut buffer_edits = Vec::new();
match rng.gen_range(0..=100) {
0..=19 => {
wrap_width = if rng.gen_bool(0.2) {
@@ -1090,7 +1091,11 @@ mod tests {
}
}
_ => {
buffer.update(&mut cx, |buffer, _| buffer.randomly_mutate(&mut rng));
buffer.update(&mut cx, |buffer, _| {
let v0 = buffer.version();
buffer.randomly_mutate(&mut rng);
buffer_edits.extend(buffer.edits_since(&v0));
});
}
}
@@ -1098,7 +1103,7 @@ mod tests {
"Unwrapped text (no folds): {:?}",
buffer.read_with(&cx, |buf, _| buf.text())
);
let (folds_snapshot, fold_edits) = cx.read(|cx| fold_map.read(cx));
let (folds_snapshot, fold_edits) = cx.read(|cx| fold_map.read(buffer_edits, cx));
log::info!(
"Unwrapped text (unexpanded tabs): {:?}",
folds_snapshot.text()
crates/editor/src/editor.rs
+2 -2
View File
@@ -3466,13 +3466,13 @@ impl Editor {
cx: &mut ViewContext<Self>,
) {
match event {
language::Event::Edited => cx.emit(Event::Edited),
language::Event::Edited(_) => cx.emit(Event::Edited),
language::Event::Dirtied => cx.emit(Event::Dirtied),
language::Event::Saved => cx.emit(Event::Saved),
language::Event::FileHandleChanged => cx.emit(Event::FileHandleChanged),
language::Event::Reloaded => cx.emit(Event::FileHandleChanged),
language::Event::Closed => cx.emit(Event::Closed),
language::Event::Reparsed => {}
_ => {}
}
}