From 59bbe43a46fd9b31392f8463a80b2a6fcb40fd9f Mon Sep 17 00:00:00 2001 From: Antonio Scandurra Date: Thu, 11 Nov 2021 16:00:52 +0100 Subject: [PATCH] WIP Co-Authored-By: Nathan Sobo --- crates/editor/src/display_map.rs | 3 +- .../editor/src/display_map/injection_map.rs | 586 ------------------ crates/editor/src/display_map/wrap_map.rs | 104 +++- 3 files changed, 91 insertions(+), 602 deletions(-) delete mode 100644 crates/editor/src/display_map/injection_map.rs diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rs index 7497e477b6..9e9fa4a664 100644 --- a/crates/editor/src/display_map.rs +++ b/crates/editor/src/display_map.rs @@ -1,6 +1,5 @@ mod block_map; mod fold_map; -mod injection_map; mod tab_map; mod wrap_map; @@ -53,7 +52,7 @@ impl DisplayMap { pub fn snapshot(&self, cx: &mut ModelContext) -> DisplayMapSnapshot { let (folds_snapshot, edits) = self.fold_map.read(cx); let (tabs_snapshot, edits) = self.tab_map.sync(folds_snapshot.clone(), edits); - let wraps_snapshot = self + let (wraps_snapshot, _) = self .wrap_map .update(cx, |map, cx| map.sync(tabs_snapshot.clone(), edits, cx)); DisplayMapSnapshot { diff --git a/crates/editor/src/display_map/injection_map.rs b/crates/editor/src/display_map/injection_map.rs deleted file mode 100644 index 995190775c..0000000000 --- a/crates/editor/src/display_map/injection_map.rs +++ /dev/null @@ -1,586 +0,0 @@ -use std::{ - cmp::{self, Ordering}, - collections::BTreeMap, - mem, - sync::atomic::{AtomicUsize, Ordering::SeqCst}, -}; - -use buffer::{Anchor, Bias, Edit, Point, Rope, TextSummary, ToOffset, ToPoint}; -use gpui::{fonts::HighlightStyle, AppContext, ModelHandle}; -use language::Buffer; -use parking_lot::Mutex; -use sum_tree::SumTree; -use util::post_inc; - -#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd)] -pub struct InjectionId(usize); - -pub struct InjectionMap { - buffer: ModelHandle, - transforms: Mutex>, - injections: SumTree, - injection_sites: SumTree, - version: AtomicUsize, - last_sync: Mutex, - next_injection_id: usize, -} - -pub struct Snapshot { - transforms: SumTree, - injections: SumTree, - buffer_snapshot: language::Snapshot, - pub version: usize, -} - -pub struct InjectionMapWriter<'a>(&'a mut InjectionMap); - -#[derive(Clone)] -struct SyncState { - version: clock::Global, - parse_count: usize, - diagnostics_update_count: usize, -} - -#[derive(Clone, Debug)] -struct InjectionSummary { - min_id: InjectionId, - max_id: InjectionId, - min_position: Anchor, - max_position: Anchor, -} - -#[derive(Clone, Debug)] -struct Injection { - id: InjectionId, - text: Rope, - runs: Vec<(usize, HighlightStyle)>, -} - -#[derive(Clone, Debug)] -pub struct InjectionProps { - text: Rope, - runs: Vec<(usize, HighlightStyle)>, - disposition: Disposition, -} - -#[derive(Clone, Debug)] -pub enum Disposition { - BeforeLine, - AfterLine, -} - -#[derive(Clone, Debug)] -struct InjectionSite { - injection_id: InjectionId, - position: Anchor, - disposition: Disposition, -} - -#[derive(Clone, Debug)] -struct InjectionSitePosition(Anchor); - -#[derive(Clone, Debug, Eq, PartialEq)] -struct InjectionSiteSummary { - min_injection_id: InjectionId, - max_injection_id: InjectionId, - min_position: Anchor, - max_position: Anchor, -} - -#[derive(Clone, Debug, Default, PartialEq)] -struct Transform { - input: TextSummary, - output: TextSummary, - injection_id: Option, -} - -#[derive(Clone, Debug, Default, Eq, PartialEq)] -struct TransformSummary { - input: TextSummary, - output: TextSummary, - min_injection_id: InjectionId, - max_injection_id: InjectionId, -} - -#[derive(Copy, Clone, Debug, Default)] -pub struct InjectionOffset(usize); - -impl sum_tree::Summary for InjectionId { - type Context = (); - - fn add_summary(&mut self, summary: &Self, cx: &Self::Context) { - *self = *summary - } -} - -impl InjectionMap { - pub fn new(buffer_handle: ModelHandle, cx: &AppContext) -> (Self, Snapshot) { - let buffer = buffer_handle.read(cx); - let this = Self { - buffer: buffer_handle, - injections: Default::default(), - injection_sites: Default::default(), - transforms: Mutex::new(SumTree::from_item( - Transform::isomorphic(buffer.text_summary()), - &(), - )), - last_sync: Mutex::new(SyncState { - version: buffer.version(), - parse_count: buffer.parse_count(), - diagnostics_update_count: buffer.diagnostics_update_count(), - }), - version: AtomicUsize::new(0), - next_injection_id: 0, - }; - let (snapshot, _) = this.read(cx); - (this, snapshot) - } - - pub fn read(&self, cx: &AppContext) -> (Snapshot, Vec>) { - let edits = self.sync(cx); - // self.check_invariants(cx); - let snapshot = Snapshot { - transforms: self.transforms.lock().clone(), - injections: self.injections.clone(), - buffer_snapshot: self.buffer.read(cx).snapshot(), - version: self.version.load(SeqCst), - }; - (snapshot, edits) - } - - pub fn write( - &mut self, - cx: &AppContext, - ) -> (InjectionMapWriter, Snapshot, Vec>) { - let (snapshot, edits) = self.read(cx); - (InjectionMapWriter(self), snapshot, edits) - } - - fn sync(&self, cx: &AppContext) -> Vec> { - 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::>(); - 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 apply_edits( - &self, - buffer_edits: Vec>, - cx: &AppContext, - ) -> Vec> { - let buffer = self.buffer.read(cx); - let mut buffer_edits_iter = buffer_edits.iter().cloned().peekable(); - - let mut new_transforms = SumTree::::new(); - let mut transforms = self.transforms.lock(); - let old_max_point = transforms.summary().input.lines; - let new_max_point = buffer.max_point(); - let mut cursor = transforms.cursor::(); - let mut injection_sites = self.injection_sites.cursor::(); - let mut pending_after_injections: Vec = Vec::new(); - - while let Some(mut edit) = buffer_edits_iter.next() { - dbg!(&edit); - // Expand this edit to line boundaries. - edit.old.start.column = 0; - edit.old.end += Point::new(1, 0); - edit.new.start.column = 0; - edit.new.end += Point::new(1, 0); - - // Push any transforms preceding the edit. - new_transforms.push_tree(cursor.slice(&edit.old.start, Bias::Left, &()), &()); - - // Snap edits to row boundaries of intersecting transforms. - loop { - if cmp::min(edit.old.end, old_max_point) <= cursor.end(&()) { - cursor.seek(&edit.old.end, Bias::Left, &()); - cursor.next(&()); - let new_old_end = *cursor.start() + Point::new(1, 0); - edit.new.end += new_old_end - edit.old.end; - edit.old.end = new_old_end; - } - - if buffer_edits_iter.peek().map_or(false, |next_edit| { - edit.old.end.row >= next_edit.old.start.row - }) { - let next_edit = buffer_edits_iter.next().unwrap(); - edit.old.end = cmp::max(edit.old.end, next_edit.old.end + Point::new(1, 0)); - let row_delta = (next_edit.new.end.row as i32 - next_edit.new.start.row as i32) - - (next_edit.old.end.row as i32 - next_edit.old.start.row as i32); - edit.new.end.row = (edit.new.end.row as i32 + row_delta) as u32; - } else { - break; - } - } - - dbg!(&edit); - - // Find and insert all injections on the lines spanned by the edit, interleaved with isomorphic regions - injection_sites.seek( - &InjectionSitePosition(buffer.anchor_before(edit.new.start)), - Bias::Right, - buffer, - ); - let mut last_injection_row: Option = None; - while let Some(site) = injection_sites.item() { - let injection_row = site.position.to_point(buffer).row; - - if injection_row > edit.new.end.row { - break; - } - - // If we've moved on to a new injection row, ensure that any pending injections with an after - // disposition are inserted after their target row - if let Some(last_injection_row) = last_injection_row { - if injection_row != last_injection_row { - let injection_point = Point::new(last_injection_row + 1, 0); - if injection_point > new_transforms.summary().input.lines { - let injection_offset = injection_point.to_offset(buffer); - new_transforms.push( - Transform::isomorphic(buffer.text_summary_for_range( - new_transforms.summary().input.bytes..injection_offset, - )), - &(), - ); - } - for injection_id in pending_after_injections.drain(..) { - new_transforms.push( - Transform::for_injection( - self.injections.get(&injection_id, &()).unwrap(), - ), - &(), - ) - } - } - } - - match site.disposition { - Disposition::AfterLine => pending_after_injections.push(site.injection_id), - Disposition::BeforeLine => { - let injection_point = Point::new(injection_row, 0); - if injection_point > new_transforms.summary().input.lines { - let injection_offset = injection_point.to_offset(buffer); - new_transforms.push( - Transform::isomorphic(buffer.text_summary_for_range( - new_transforms.summary().input.bytes..injection_offset, - )), - &(), - ); - } - new_transforms.push( - Transform::for_injection( - self.injections.get(&site.injection_id, &()).unwrap(), - ), - &(), - ); - } - } - - last_injection_row = Some(injection_row); - } - - if let Some(last_injection_row) = last_injection_row { - let injection_point = Point::new(last_injection_row + 1, 0); - if injection_point > new_transforms.summary().input.lines { - let injection_offset = injection_point.to_offset(buffer); - new_transforms.push( - Transform::isomorphic(buffer.text_summary_for_range( - new_transforms.summary().input.bytes..injection_offset, - )), - &(), - ); - } - for injection_id in pending_after_injections.drain(..) { - new_transforms.push( - Transform::for_injection(self.injections.get(&injection_id, &()).unwrap()), - &(), - ) - } - } - - let sum = new_transforms.summary(); - let new_end = cmp::min(edit.new.end, new_max_point); - if sum.input.lines < new_end { - let text_summary = - buffer.text_summary_for_range(sum.input.bytes..new_end.to_offset(buffer)); - new_transforms.push(Transform::isomorphic(text_summary), &()); - } - } - new_transforms.push_tree(cursor.suffix(&()), &()); - drop(cursor); - - *transforms = new_transforms; - Vec::new() - } -} - -impl<'a> InjectionMapWriter<'a> { - pub fn insert<'b, T, U>( - &mut self, - injections: T, - cx: &AppContext, - ) -> (Vec, Snapshot, Vec>) - where - T: IntoIterator, - { - let buffer = self.0.buffer.read(cx); - let mut cursor = self.0.injection_sites.cursor::(); - let mut new_sites = SumTree::new(); - let mut injection_ids = Vec::new(); - let mut edits = Vec::new(); - - for (position, props) in injections { - let point = position.to_point(buffer); - edits.push(Edit { - old: point..point, - new: point..point, - }); - - let id = InjectionId(post_inc(&mut self.0.next_injection_id)); - injection_ids.push(id); - new_sites.push_tree( - cursor.slice( - &InjectionSitePosition(position.clone()), - Bias::Right, - buffer, - ), - buffer, - ); - new_sites.push( - InjectionSite { - injection_id: id, - position, - disposition: props.disposition, - }, - buffer, - ); - self.0.injections.push( - Injection { - id, - text: props.text, - runs: props.runs, - }, - &(), - ); - } - new_sites.push_tree(cursor.suffix(buffer), buffer); - - drop(cursor); - self.0.injection_sites = new_sites; - - let edits = self.0.apply_edits(edits, cx); - let snapshot = Snapshot { - transforms: self.0.transforms.lock().clone(), - injections: self.0.injections.clone(), - buffer_snapshot: buffer.snapshot(), - version: self.0.version.load(SeqCst), - }; - - (injection_ids, snapshot, edits) - } -} - -impl sum_tree::Item for Injection { - type Summary = InjectionId; - - fn summary(&self) -> Self::Summary { - self.id - } -} - -impl sum_tree::KeyedItem for Injection { - type Key = InjectionId; - - fn key(&self) -> Self::Key { - self.id - } -} - -impl sum_tree::Item for InjectionSite { - type Summary = InjectionSiteSummary; - - fn summary(&self) -> Self::Summary { - InjectionSiteSummary { - min_injection_id: self.injection_id, - max_injection_id: self.injection_id, - min_position: self.position.clone(), - max_position: self.position.clone(), - } - } -} - -impl Default for InjectionSitePosition { - fn default() -> Self { - Self(Anchor::min()) - } -} - -impl sum_tree::Summary for InjectionSiteSummary { - type Context = buffer::Buffer; - - fn add_summary(&mut self, summary: &Self, _: &Self::Context) { - self.min_injection_id = cmp::min(self.min_injection_id, summary.min_injection_id); - self.max_injection_id = cmp::max(self.max_injection_id, summary.max_injection_id); - self.max_position = summary.max_position.clone(); - } -} - -impl<'a> sum_tree::Dimension<'a, InjectionSiteSummary> for InjectionSitePosition { - fn add_summary(&mut self, summary: &'a InjectionSiteSummary, _: &buffer::Buffer) { - self.0 = summary.max_position.clone(); - } -} - -impl<'a> sum_tree::SeekTarget<'a, InjectionSiteSummary, Self> for InjectionSitePosition { - fn cmp(&self, cursor_location: &Self, snapshot: &buffer::Buffer) -> Ordering { - self.0.cmp(&cursor_location.0, snapshot).unwrap() - } -} - -impl Default for InjectionSiteSummary { - fn default() -> Self { - Self { - min_injection_id: InjectionId(usize::MAX), - max_injection_id: InjectionId(0), - min_position: Anchor::max(), - max_position: Anchor::min(), - } - } -} - -impl Transform { - fn isomorphic(text_summary: TextSummary) -> Self { - Self { - input: text_summary.clone(), - output: text_summary, - injection_id: None, - } - } - - fn for_injection(injection: &Injection) -> Self { - Self { - input: Default::default(), - output: injection.text.summary(), - injection_id: Some(injection.id), - } - } -} - -impl sum_tree::Item for Transform { - type Summary = TransformSummary; - - fn summary(&self) -> Self::Summary { - let min_injection_id; - let max_injection_id; - if let Some(id) = self.injection_id { - min_injection_id = id; - max_injection_id = id; - } else { - min_injection_id = InjectionId(usize::MAX); - max_injection_id = InjectionId(0); - } - - TransformSummary { - input: self.input.clone(), - output: self.output.clone(), - min_injection_id, - max_injection_id, - } - } -} - -impl sum_tree::Summary for TransformSummary { - type Context = (); - - fn add_summary(&mut self, other: &Self, _: &()) { - self.input += &other.input; - self.output += &other.output; - } -} - -impl<'a> sum_tree::Dimension<'a, TransformSummary> for usize { - fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { - *self += summary.input.bytes - } -} - -impl<'a> sum_tree::Dimension<'a, TransformSummary> for Point { - fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { - *self += summary.input.lines - } -} - -impl<'a> sum_tree::Dimension<'a, TransformSummary> for InjectionOffset { - fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { - self.0 += summary.output.bytes - } -} - -#[cfg(test)] -mod tests { - use std::env; - - use super::*; - use buffer::RandomCharIter; - use rand::prelude::*; - - #[gpui::test(iterations = 1000)] - fn test_random(cx: &mut gpui::MutableAppContext, mut rng: StdRng) { - let operations = env::var("OPERATIONS") - .map(|i| i.parse().expect("invalid `OPERATIONS` variable")) - .unwrap_or(1); - - let buffer = cx.add_model(|cx| { - let len = rng.gen_range(0..10); - let text = RandomCharIter::new(&mut rng).take(len).collect::(); - Buffer::new(0, text, cx) - }); - let (map, initial_snapshot) = InjectionMap::new(buffer.clone(), cx.as_ref()); - assert_eq!( - initial_snapshot.transforms.summary().input, - buffer.read(cx).text_summary() - ); - - for _ in 0..operations { - log::info!("text: {:?}", buffer.read(cx).text()); - match rng.gen_range(0..=100) { - _ => { - 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::(&start_version) - .collect::>() - }); - log::info!("editing {:?}", edits); - } - } - - let (snapshot, edits) = map.read(cx.as_ref()); - assert_eq!( - snapshot.transforms.summary().input, - buffer.read(cx).text_summary() - ); - } - } -} diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs index 5991d060a0..9649d7bf9a 100644 --- a/crates/editor/src/display_map/wrap_map.rs +++ b/crates/editor/src/display_map/wrap_map.rs @@ -6,7 +6,7 @@ use gpui::{fonts::FontId, text_layout::LineWrapper, Entity, ModelContext, Task}; use language::{HighlightedChunk, Point}; use lazy_static::lazy_static; use smol::future::yield_now; -use std::{collections::VecDeque, ops::Range, time::Duration}; +use std::{collections::VecDeque, mem, ops::Range, time::Duration}; use sum_tree::{Bias, Cursor, SumTree}; pub type Edit = buffer::Edit; @@ -14,11 +14,16 @@ pub type Edit = buffer::Edit; pub struct WrapMap { snapshot: Snapshot, pending_edits: VecDeque<(TabSnapshot, Vec)>, + interpolated_edits: Patch, + edits_since_sync: Patch, wrap_width: Option, background_task: Option>, font: (FontId, f32), } +#[derive(Default)] +struct Patch(Vec); + impl Entity for WrapMap { type Event = (); } @@ -81,6 +86,8 @@ impl WrapMap { font: (font_id, font_size), wrap_width: None, pending_edits: Default::default(), + interpolated_edits: Default::default(), + edits_since_sync: Default::default(), snapshot: Snapshot::new(tab_snapshot), background_task: None, }; @@ -99,10 +106,13 @@ impl WrapMap { tab_snapshot: TabSnapshot, edits: Vec, cx: &mut ModelContext, - ) -> Snapshot { + ) -> (Snapshot, Vec) { self.pending_edits.push_back((tab_snapshot, edits)); self.flush_edits(cx); - self.snapshot.clone() + ( + self.snapshot.clone(), + mem::take(&mut self.edits_since_sync).0, + ) } pub fn set_font(&mut self, font_id: FontId, font_size: f32, cx: &mut ModelContext) { @@ -204,26 +214,32 @@ impl WrapMap { let update_task = cx.background().spawn(async move { let mut line_wrapper = font_cache.line_wrapper(font_id, font_size); + let mut output_edits = Patch::default(); for (tab_snapshot, edits) in pending_edits { - snapshot + let wrap_edits = snapshot .update(tab_snapshot, &edits, wrap_width, &mut line_wrapper) .await; + output_edits.compose(&wrap_edits); } - snapshot + (snapshot, output_edits) }); match cx .background() .block_with_timeout(Duration::from_millis(1), update_task) { - Ok(snapshot) => { + Ok((snapshot, output_edits)) => { self.snapshot = snapshot; + self.edits_since_sync.compose(&output_edits); } Err(update_task) => { self.background_task = Some(cx.spawn(|this, mut cx| async move { - let snapshot = update_task.await; + let (snapshot, output_edits) = update_task.await; this.update(&mut cx, |this, cx| { this.snapshot = snapshot; + this.edits_since_sync + .compose(mem::take(&mut this.interpolated_edits).invert()) + .compose(&output_edits); this.background_task = None; this.flush_edits(cx); cx.notify(); @@ -240,7 +256,9 @@ impl WrapMap { if tab_snapshot.version() <= self.snapshot.tab_snapshot.version() { to_remove_len += 1; } else { - self.snapshot.interpolate(tab_snapshot.clone(), &edits); + let interpolated_edits = self.snapshot.interpolate(tab_snapshot.clone(), &edits); + self.edits_since_sync.compose(&interpolated_edits); + self.interpolated_edits.compose(&interpolated_edits); } } @@ -250,6 +268,59 @@ impl WrapMap { } } +impl Patch { + fn compose(&mut self, other: &Self) -> &mut Self { + + // let mut other_ranges = edit.ranges.iter().peekable(); + // let mut new_ranges = Vec::new(); + // let insertion_len = edit.new_text.as_ref().map_or(0, |t| t.len()); + // let mut delta = 0; + + // for mut self_range in self.ranges.iter().cloned() { + // self_range.start += delta; + // self_range.end += delta; + + // while let Some(other_range) = other_ranges.peek() { + // let mut other_range = (*other_range).clone(); + // other_range.start += delta; + // other_range.end += delta; + + // if other_range.start <= self_range.end { + // other_ranges.next().unwrap(); + // delta += insertion_len; + + // if other_range.end < self_range.start { + // new_ranges.push(other_range.start..other_range.end + insertion_len); + // self_range.start += insertion_len; + // self_range.end += insertion_len; + // } else { + // self_range.start = cmp::min(self_range.start, other_range.start); + // self_range.end = cmp::max(self_range.end, other_range.end) + insertion_len; + // } + // } else { + // break; + // } + // } + + // new_ranges.push(self_range); + // } + + // for other_range in other_ranges { + // new_ranges.push(other_range.start + delta..other_range.end + delta + insertion_len); + // delta += insertion_len; + // } + + // self.ranges = new_ranges; + } + + fn invert(&mut self) -> &mut Self { + for edit in &mut self.0 { + mem::swap(&mut edit.old, &mut edit.new); + } + self + } +} + impl Snapshot { fn new(tab_snapshot: TabSnapshot) -> Self { let mut transforms = SumTree::new(); @@ -264,7 +335,7 @@ impl Snapshot { } } - fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, edits: &[TabEdit]) { + fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, edits: &[TabEdit]) -> Patch { let mut new_transforms; if edits.is_empty() { new_transforms = self.transforms.clone(); @@ -320,6 +391,7 @@ impl Snapshot { self.tab_snapshot = new_tab_snapshot; self.interpolated = true; self.check_invariants(); + todo!() } async fn update( @@ -328,7 +400,7 @@ impl Snapshot { edits: &[TabEdit], wrap_width: f32, line_wrapper: &mut LineWrapper, - ) { + ) -> Patch { #[derive(Debug)] struct RowEdit { old_rows: Range, @@ -458,6 +530,7 @@ impl Snapshot { self.tab_snapshot = new_tab_snapshot; self.interpolated = false; self.check_invariants(); + todo!() } pub fn chunks_at(&self, wrap_row: u32) -> Chunks { @@ -896,6 +969,8 @@ impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapPoint { } } +fn compose(prev: &mut Vec, next: &[Edit]) {} + #[cfg(test)] mod tests { use super::*; @@ -962,7 +1037,8 @@ mod tests { notifications.recv().await.unwrap(); } - let snapshot = wrap_map.update(&mut cx, |map, cx| map.sync(tabs_snapshot, Vec::new(), cx)); + let (snapshot, _) = + wrap_map.update(&mut cx, |map, cx| map.sync(tabs_snapshot, Vec::new(), cx)); let actual_text = snapshot.text(); assert_eq!( actual_text, expected_text, @@ -987,7 +1063,7 @@ mod tests { cx.read(|cx| fold_map.randomly_mutate(&mut rng, cx)) { let (tabs_snapshot, edits) = tab_map.sync(folds_snapshot, edits); - let mut snapshot = + let (mut snapshot, _) = wrap_map.update(&mut cx, |map, cx| map.sync(tabs_snapshot, edits, cx)); snapshot.check_invariants(); snapshot.verify_chunks(&mut rng); @@ -1012,7 +1088,7 @@ mod tests { let unwrapped_text = tabs_snapshot.text(); let expected_text = wrap_text(&unwrapped_text, wrap_width, &mut line_wrapper); - let mut snapshot = wrap_map.update(&mut cx, |map, cx| { + let (mut snapshot, _) = wrap_map.update(&mut cx, |map, cx| { map.sync(tabs_snapshot.clone(), edits, cx) }); snapshot.check_invariants(); @@ -1026,7 +1102,7 @@ mod tests { } if !wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) { - let mut wrapped_snapshot = + let (mut wrapped_snapshot, _) = wrap_map.update(&mut cx, |map, cx| map.sync(tabs_snapshot, Vec::new(), cx)); let actual_text = wrapped_snapshot.text(); log::info!("Wrapping finished: {:?}", actual_text);