diff --git a/zed/src/editor/buffer.rs b/zed/src/editor/buffer.rs index 390149646e..2241b87b2f 100644 --- a/zed/src/editor/buffer.rs +++ b/zed/src/editor/buffer.rs @@ -360,7 +360,7 @@ struct FragmentTextSummary { } impl<'a> sum_tree::Dimension<'a, FragmentSummary> for FragmentTextSummary { - fn add_summary(&mut self, summary: &'a FragmentSummary) { + fn add_summary(&mut self, summary: &'a FragmentSummary, _: &()) { self.visible += summary.text.visible; self.deleted += summary.text.deleted; } @@ -825,7 +825,7 @@ impl Buffer { } pub fn len(&self) -> usize { - self.fragments.extent::() + self.fragments.extent::(&()) } pub fn line_len(&self, row: u32) -> u32 { @@ -871,9 +871,10 @@ impl Buffer { pub fn edits_since<'a>(&'a self, since: time::Global) -> impl 'a + Iterator { let since_2 = since.clone(); - let cursor = self - .fragments - .filter(move |summary| summary.max_version.changed_since(&since_2)); + let cursor = self.fragments.filter( + move |summary| summary.max_version.changed_since(&since_2), + &(), + ); Edits { deleted_text: &self.deleted_text, @@ -1201,7 +1202,7 @@ impl Buffer { let fragment = fragments_cursor.item().unwrap().clone(); new_ropes.push_fragment(&fragment, fragment.visible); new_fragments.push(fragment, &()); - fragments_cursor.next(); + fragments_cursor.next(&()); } while let Some(fragment) = fragments_cursor.item() { @@ -1291,7 +1292,7 @@ impl Buffer { new_fragments.push(fragment, &()); } - fragments_cursor.next(); + fragments_cursor.next(&()); } if let Some(new_text) = new_text { @@ -1420,7 +1421,7 @@ impl Buffer { new_ropes.push_fragment(&fragment, was_visible); new_fragments.push(fragment.clone(), &()); - fragments_cursor.next(); + fragments_cursor.next(&()); if let Some(split_id) = insertion_splits.next() { let slice = fragments_cursor.slice(&FragmentIdRef::new(split_id), SeekBias::Left, &()); @@ -1453,7 +1454,7 @@ impl Buffer { new_ropes.push_fragment(&fragment, fragment_was_visible); new_fragments.push(fragment, &()); - fragments_cursor.next(); + fragments_cursor.next(&()); } } } @@ -1704,9 +1705,9 @@ impl Buffer { }, &(), ); - splits_cursor.next(); + splits_cursor.next(&()); new_split_tree.push_tree( - splits_cursor.slice(&old_split_tree.extent::(), SeekBias::Right, &()), + splits_cursor.slice(&old_split_tree.extent::(&()), SeekBias::Right, &()), &(), ); self.insertion_splits @@ -1716,7 +1717,7 @@ impl Buffer { new_fragments.push(fragment, &()); // Scan forward until we find a fragment that is not fully contained by the current splice. - fragments_cursor.next(); + fragments_cursor.next(&()); if let Some(range) = cur_range.clone() { while let Some(fragment) = fragments_cursor.item() { let fragment_summary = fragments_cursor.item_summary().unwrap(); @@ -1733,7 +1734,7 @@ impl Buffer { new_ropes.push_fragment(&new_fragment, fragment_was_visible); new_fragments.push(new_fragment, &()); - fragments_cursor.next(); + fragments_cursor.next(&()); if range.end == fragment_end { end_id = Some(fragment.insertion.id); @@ -1912,9 +1913,9 @@ impl Buffer { ); } - cursor.next(); + cursor.next(&()); new_split_tree.push_tree( - cursor.slice(&old_split_tree.extent::(), SeekBias::Right, &()), + cursor.slice(&old_split_tree.extent::(&()), SeekBias::Right, &()), &(), ); @@ -2261,7 +2262,7 @@ impl<'a, F: Fn(&FragmentSummary) -> bool> Iterator for Edits<'a, F> { } } - self.cursor.next(); + self.cursor.next(&()); } change @@ -2445,7 +2446,7 @@ impl<'a> FragmentIdRef<'a> { } impl<'a> sum_tree::Dimension<'a, FragmentSummary> for FragmentIdRef<'a> { - fn add_summary(&mut self, summary: &'a FragmentSummary) { + fn add_summary(&mut self, summary: &'a FragmentSummary, _: &()) { self.0 = Some(&summary.max_fragment_id) } } @@ -2543,7 +2544,7 @@ impl Default for FragmentSummary { } impl<'a> sum_tree::Dimension<'a, FragmentSummary> for usize { - fn add_summary(&mut self, summary: &FragmentSummary) { + fn add_summary(&mut self, summary: &FragmentSummary, _: &()) { *self += summary.text.visible; } } @@ -2573,7 +2574,7 @@ impl Default for InsertionSplitSummary { } impl<'a> sum_tree::Dimension<'a, InsertionSplitSummary> for usize { - fn add_summary(&mut self, summary: &InsertionSplitSummary) { + fn add_summary(&mut self, summary: &InsertionSplitSummary, _: &()) { *self += summary.extent; } } @@ -3661,7 +3662,7 @@ mod tests { let text = " mod x { mod y { - + } } " diff --git a/zed/src/editor/buffer/rope.rs b/zed/src/editor/buffer/rope.rs index 98b317c0ed..05b30e3896 100644 --- a/zed/src/editor/buffer/rope.rs +++ b/zed/src/editor/buffer/rope.rs @@ -25,13 +25,13 @@ impl Rope { pub fn append(&mut self, rope: Rope) { let mut chunks = rope.chunks.cursor::<(), ()>(); - chunks.next(); + chunks.next(&()); if let Some(chunk) = chunks.item() { if self.chunks.last().map_or(false, |c| c.0.len() < CHUNK_BASE) || chunk.0.len() < CHUNK_BASE { self.push(&chunk.0); - chunks.next(); + chunks.next(&()); } } @@ -99,11 +99,11 @@ impl Rope { } pub fn len(&self) -> usize { - self.chunks.extent() + self.chunks.extent(&()) } pub fn max_point(&self) -> Point { - self.chunks.extent() + self.chunks.extent(&()) } pub fn cursor(&self, offset: usize) -> Cursor { @@ -218,12 +218,12 @@ impl<'a> Cursor<'a> { let mut slice = Rope::new(); if let Some(start_chunk) = self.chunks.item() { let start_ix = self.offset - self.chunks.start(); - let end_ix = cmp::min(end_offset, self.chunks.end()) - self.chunks.start(); + let end_ix = cmp::min(end_offset, self.chunks.end(&())) - self.chunks.start(); slice.push(&start_chunk.0[start_ix..end_ix]); } - if end_offset > self.chunks.end() { - self.chunks.next(); + if end_offset > self.chunks.end(&()) { + self.chunks.next(&()); slice.append(Rope { chunks: self.chunks.slice(&end_offset, SeekBias::Right, &()), }); @@ -243,12 +243,12 @@ impl<'a> Cursor<'a> { let mut summary = TextSummary::default(); if let Some(start_chunk) = self.chunks.item() { let start_ix = self.offset - self.chunks.start(); - let end_ix = cmp::min(end_offset, self.chunks.end()) - self.chunks.start(); + let end_ix = cmp::min(end_offset, self.chunks.end(&())) - self.chunks.start(); summary = TextSummary::from(&start_chunk.0[start_ix..end_ix]); } - if end_offset > self.chunks.end() { - self.chunks.next(); + if end_offset > self.chunks.end(&()) { + self.chunks.next(&()); summary += &self.chunks.summary(&end_offset, SeekBias::Right, &()); if let Some(end_chunk) = self.chunks.item() { let end_ix = end_offset - self.chunks.start(); @@ -260,7 +260,7 @@ impl<'a> Cursor<'a> { } pub fn suffix(mut self) -> Rope { - self.slice(self.rope.chunks.extent()) + self.slice(self.rope.chunks.extent(&())) } pub fn offset(&self) -> usize { @@ -285,7 +285,7 @@ impl<'a> Chunks<'a> { } pub fn seek(&mut self, offset: usize) { - if offset >= self.chunks.end() { + if offset >= self.chunks.end(&()) { self.chunks.seek_forward(&offset, SeekBias::Right, &()); } else { self.chunks.seek(&offset, SeekBias::Right, &()); @@ -312,7 +312,7 @@ impl<'a> Iterator for Chunks<'a> { fn next(&mut self) -> Option { let result = self.peek(); if result.is_some() { - self.chunks.next(); + self.chunks.next(&()); } result } @@ -478,19 +478,19 @@ impl std::ops::AddAssign for TextSummary { } impl<'a> sum_tree::Dimension<'a, TextSummary> for TextSummary { - fn add_summary(&mut self, summary: &'a TextSummary) { + fn add_summary(&mut self, summary: &'a TextSummary, _: &()) { *self += summary; } } impl<'a> sum_tree::Dimension<'a, TextSummary> for usize { - fn add_summary(&mut self, summary: &'a TextSummary) { + fn add_summary(&mut self, summary: &'a TextSummary, _: &()) { *self += summary.bytes; } } impl<'a> sum_tree::Dimension<'a, TextSummary> for Point { - fn add_summary(&mut self, summary: &'a TextSummary) { + fn add_summary(&mut self, summary: &'a TextSummary, _: &()) { *self += &summary.lines; } } diff --git a/zed/src/editor/display_map/fold_map.rs b/zed/src/editor/display_map/fold_map.rs index 1866e86608..135ecb566f 100644 --- a/zed/src/editor/display_map/fold_map.rs +++ b/zed/src/editor/display_map/fold_map.rs @@ -12,6 +12,7 @@ use gpui::{AppContext, ModelHandle}; use parking_lot::{Mutex, MutexGuard}; use std::{ cmp::{self, Ordering}, + iter, ops::Range, }; @@ -80,7 +81,13 @@ impl FoldMap { where T: ToOffset, { - self.intersecting_folds(range, cx).map(|f| &f.0) + let buffer = self.buffer.read(cx); + let mut folds = self.intersecting_folds(range, cx); + iter::from_fn(move || { + let item = folds.item().map(|f| &f.0); + folds.next(buffer); + item + }) } pub fn fold( @@ -149,7 +156,7 @@ impl FoldMap { ..Default::default() }); fold_ixs_to_delete.push(*folds_cursor.start()); - folds_cursor.next(); + folds_cursor.next(buffer); } } @@ -167,7 +174,7 @@ impl FoldMap { let mut folds = SumTree::new(); for fold_ix in fold_ixs_to_delete { folds.push_tree(cursor.slice(&fold_ix, SeekBias::Right, buffer), buffer); - cursor.next(); + cursor.next(buffer); } folds.push_tree(cursor.suffix(buffer), buffer); folds @@ -186,10 +193,13 @@ impl FoldMap { let buffer = self.buffer.read(cx); let start = buffer.anchor_before(range.start.to_offset(buffer)); let end = buffer.anchor_after(range.end.to_offset(buffer)); - self.folds.filter::<_, usize>(move |summary| { - start.cmp(&summary.max_end, buffer).unwrap() == Ordering::Less - && end.cmp(&summary.min_start, buffer).unwrap() == Ordering::Greater - }) + self.folds.filter::<_, usize>( + move |summary| { + start.cmp(&summary.max_end, buffer).unwrap() == Ordering::Less + && end.cmp(&summary.min_start, buffer).unwrap() == Ordering::Greater + }, + buffer, + ) } pub fn intersects_fold(&self, offset: T, cx: &AppContext) -> bool @@ -212,8 +222,8 @@ impl FoldMap { if transform.display_text.is_some() { return true; } - if cursor.end().row() == display_row { - cursor.next() + if cursor.end(&()).row() == display_row { + cursor.next(&()) } else { break; } @@ -244,7 +254,7 @@ impl FoldMap { let overshoot = point - cursor.start().buffer.lines; DisplayPoint(cmp::min( cursor.start().display.lines + overshoot, - cursor.end().display.lines, + cursor.end(&()).display.lines, )) } @@ -276,7 +286,7 @@ impl FoldMap { edit.old_range.start = *cursor.start(); cursor.seek(&edit.old_range.end, SeekBias::Right, &()); - cursor.next(); + cursor.next(&()); let mut delta = edit.delta(); loop { @@ -293,7 +303,7 @@ impl FoldMap { if next_edit.old_range.end >= edit.old_range.end { edit.old_range.end = next_edit.old_range.end; cursor.seek(&edit.old_range.end, SeekBias::Right, &()); - cursor.next(); + cursor.next(&()); } } else { break; @@ -306,9 +316,14 @@ impl FoldMap { let anchor = buffer.anchor_before(edit.new_range.start); let mut folds_cursor = self.folds.cursor::<_, ()>(); folds_cursor.seek(&Fold(anchor..Anchor::End), SeekBias::Left, buffer); - let mut folds = folds_cursor - .map(|f| f.0.start.to_offset(buffer)..f.0.end.to_offset(buffer)) - .peekable(); + let mut folds = iter::from_fn(move || { + let item = folds_cursor + .item() + .map(|f| f.0.start.to_offset(buffer)..f.0.end.to_offset(buffer)); + folds_cursor.next(buffer); + item + }) + .peekable(); while folds .peek() @@ -501,7 +516,7 @@ impl FoldMapSnapshot { if offset.0 == transform_start || matches!(bias, Bias::Left) { DisplayOffset(transform_start) } else { - DisplayOffset(cursor.end().display.bytes) + DisplayOffset(cursor.end(&()).display.bytes) } } else { let overshoot = offset.0 - transform_start; @@ -526,7 +541,7 @@ impl FoldMapSnapshot { if point.0 == transform_start || matches!(bias, Bias::Left) { DisplayPoint(transform_start) } else { - DisplayPoint(cursor.end().display.lines) + DisplayPoint(cursor.end(&()).display.lines) } } else { let overshoot = point.0 - transform_start; @@ -574,7 +589,7 @@ impl sum_tree::Summary for TransformSummary { } impl<'a> sum_tree::Dimension<'a, TransformSummary> for TransformSummary { - fn add_summary(&mut self, summary: &'a TransformSummary) { + fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { sum_tree::Summary::add_summary(self, summary, &()); } } @@ -649,7 +664,7 @@ impl sum_tree::Summary for FoldSummary { } impl<'a> sum_tree::Dimension<'a, FoldSummary> for Fold { - fn add_summary(&mut self, summary: &'a FoldSummary) { + fn add_summary(&mut self, summary: &'a FoldSummary, _: &Buffer) { self.0.start = summary.start.clone(); self.0.end = summary.end.clone(); } @@ -662,7 +677,7 @@ impl<'a> sum_tree::SeekDimension<'a, FoldSummary> for Fold { } impl<'a> sum_tree::Dimension<'a, FoldSummary> for usize { - fn add_summary(&mut self, summary: &'a FoldSummary) { + fn add_summary(&mut self, summary: &'a FoldSummary, _: &Buffer) { *self += summary.count; } } @@ -676,8 +691,8 @@ impl<'a> Iterator for BufferRows<'a> { type Item = u32; fn next(&mut self) -> Option { - while self.display_point > self.cursor.end().display.lines { - self.cursor.next(); + while self.display_point > self.cursor.end(&()).display.lines { + self.cursor.next(&()); if self.cursor.item().is_none() { // TODO: Return a bool from next? break; @@ -717,10 +732,10 @@ impl<'a> Iterator for Chunks<'a> { self.buffer_offset += transform.summary.buffer.bytes; self.buffer_chunks.seek(self.buffer_offset); - while self.buffer_offset >= self.transform_cursor.end().buffer.bytes + while self.buffer_offset >= self.transform_cursor.end(&()).buffer.bytes && self.transform_cursor.item().is_some() { - self.transform_cursor.next(); + self.transform_cursor.next(&()); } return Some(display_text); @@ -732,10 +747,10 @@ impl<'a> Iterator for Chunks<'a> { chunk = &chunk[offset_in_chunk..]; // Truncate the chunk so that it ends at the next fold. - let region_end = self.transform_cursor.end().buffer.bytes - self.buffer_offset; + let region_end = self.transform_cursor.end(&()).buffer.bytes - self.buffer_offset; if chunk.len() >= region_end { chunk = &chunk[0..region_end]; - self.transform_cursor.next(); + self.transform_cursor.next(&()); } else { self.buffer_chunks.next(); } @@ -772,10 +787,10 @@ impl<'a> Iterator for HighlightedChunks<'a> { self.buffer_offset += transform.summary.buffer.bytes; self.buffer_chunks.seek(self.buffer_offset); - while self.buffer_offset >= self.transform_cursor.end().buffer.bytes + while self.buffer_offset >= self.transform_cursor.end(&()).buffer.bytes && self.transform_cursor.item().is_some() { - self.transform_cursor.next(); + self.transform_cursor.next(&()); } return Some((display_text, StyleId::default())); @@ -796,10 +811,10 @@ impl<'a> Iterator for HighlightedChunks<'a> { chunk = &chunk[offset_in_chunk..]; // Truncate the chunk so that it ends at the next fold. - let region_end = self.transform_cursor.end().buffer.bytes - self.buffer_offset; + let region_end = self.transform_cursor.end(&()).buffer.bytes - self.buffer_offset; if chunk.len() >= region_end { chunk = &chunk[0..region_end]; - self.transform_cursor.next(); + self.transform_cursor.next(&()); } else { self.buffer_chunk.take(); } @@ -813,7 +828,7 @@ impl<'a> Iterator for HighlightedChunks<'a> { } impl<'a> sum_tree::Dimension<'a, TransformSummary> for DisplayPoint { - fn add_summary(&mut self, summary: &'a TransformSummary) { + fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { self.0 += &summary.display.lines; } } @@ -822,19 +837,19 @@ impl<'a> sum_tree::Dimension<'a, TransformSummary> for DisplayPoint { pub struct DisplayOffset(usize); impl<'a> sum_tree::Dimension<'a, TransformSummary> for DisplayOffset { - fn add_summary(&mut self, summary: &'a TransformSummary) { + fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { self.0 += &summary.display.bytes; } } impl<'a> sum_tree::Dimension<'a, TransformSummary> for Point { - fn add_summary(&mut self, summary: &'a TransformSummary) { + fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { *self += &summary.buffer.lines; } } impl<'a> sum_tree::Dimension<'a, TransformSummary> for usize { - fn add_summary(&mut self, summary: &'a TransformSummary) { + fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) { *self += &summary.buffer.bytes; } } @@ -1027,29 +1042,6 @@ mod tests { for _ in 0..operations { log::info!("text: {:?}", buffer.read(cx).text()); - { - let buffer = buffer.read(cx); - let mut cursor = map.folds.cursor::<(), ()>(); - cursor.next(buffer); - let mut prev_fold: Option<&Fold> = None; - while let Some(fold) = cursor.item() { - if let Some(prev_fold) = prev_fold { - let prev_fold = prev_fold.0.start.to_offset(buffer) - ..prev_fold.0.end.to_offset(buffer); - let fold = fold.0.start.to_offset(buffer)..fold.0.end.to_offset(buffer); - assert!( - fold.start > prev_fold.start - || (fold.start == prev_fold.start && fold.end <= prev_fold.end), - "prev fold {:?}\ncurr fold {:?}", - prev_fold, - fold - ); - } - - prev_fold = Some(fold); - cursor.next(buffer); - } - } match rng.gen_range(0..=100) { 0..=34 => { let buffer = buffer.read(cx); @@ -1195,7 +1187,7 @@ mod tests { let start = buffer.clip_offset(rng.gen_range(0..=end), Left); let expected_folds = map .folds - .items() + .items(buffer) .into_iter() .filter(|fold| { let start = buffer.anchor_before(start); @@ -1250,7 +1242,7 @@ mod tests { fn merged_fold_ranges(&self, cx: &AppContext) -> Vec> { let buffer = self.buffer.read(cx); - let mut folds = self.folds.items(); + let mut folds = self.folds.items(buffer); // Ensure sorting doesn't change how folds get merged and displayed. folds.sort_by(|a, b| a.0.cmp(&b.0, buffer).unwrap()); let mut fold_ranges = folds diff --git a/zed/src/operation_queue.rs b/zed/src/operation_queue.rs index 2c0e234fe9..681d135870 100644 --- a/zed/src/operation_queue.rs +++ b/zed/src/operation_queue.rs @@ -89,7 +89,7 @@ impl<'a> Add<&'a Self> for OperationSummary { } impl<'a> Dimension<'a, OperationSummary> for OperationKey { - fn add_summary(&mut self, summary: &OperationSummary) { + fn add_summary(&mut self, summary: &OperationSummary, _: &()) { assert!(*self <= summary.key); *self = summary.key; } diff --git a/zed/src/sum_tree.rs b/zed/src/sum_tree.rs index 8a2f9eb475..35b9183376 100644 --- a/zed/src/sum_tree.rs +++ b/zed/src/sum_tree.rs @@ -29,11 +29,11 @@ pub trait Summary: Default + Clone + fmt::Debug { } pub trait Dimension<'a, S: Summary>: Clone + fmt::Debug + Default { - fn add_summary(&mut self, _summary: &'a S); + fn add_summary(&mut self, _summary: &'a S, _: &S::Context); } impl<'a, T: Summary> Dimension<'a, T> for () { - fn add_summary(&mut self, _: &'a T) {} + fn add_summary(&mut self, _: &'a T, _: &T::Context) {} } pub trait SeekDimension<'a, T: Summary>: Dimension<'a, T> { @@ -71,9 +71,15 @@ impl SumTree { } #[allow(unused)] - pub fn items(&self) -> Vec { + pub fn items(&self, cx: &::Context) -> Vec { + let mut items = Vec::new(); let mut cursor = self.cursor::<(), ()>(); - cursor.cloned().collect() + cursor.next(cx); + while let Some(item) = cursor.item() { + items.push(item.clone()); + cursor.next(cx); + } + items } pub fn cursor<'a, S, U>(&'a self) -> Cursor @@ -84,12 +90,16 @@ impl SumTree { Cursor::new(self) } - pub fn filter<'a, F, U>(&'a self, filter_node: F) -> FilterCursor + pub fn filter<'a, F, U>( + &'a self, + filter_node: F, + cx: &::Context, + ) -> FilterCursor where F: Fn(&T::Summary) -> bool, U: Dimension<'a, T::Summary>, { - FilterCursor::new(self, filter_node) + FilterCursor::new(self, filter_node, cx) } #[allow(dead_code)] @@ -141,11 +151,14 @@ impl SumTree { } } - pub fn extent<'a, D: Dimension<'a, T::Summary>>(&'a self) -> D { + pub fn extent<'a, D: Dimension<'a, T::Summary>>( + &'a self, + cx: &::Context, + ) -> D { let mut extent = D::default(); match self.0.as_ref() { Node::Internal { summary, .. } | Node::Leaf { summary, .. } => { - extent.add_summary(summary); + extent.add_summary(summary, cx); } } extent @@ -434,7 +447,7 @@ impl SumTree { if let Some(old_item) = old_item { if old_item.key() == new_key { removed.push(old_item.clone()); - cursor.next(); + cursor.next(cx); } } @@ -580,7 +593,10 @@ mod tests { tree2.extend(50..100, &()); tree1.push_tree(tree2, &()); - assert_eq!(tree1.items(), (0..20).chain(50..100).collect::>()); + assert_eq!( + tree1.items(&()), + (0..20).chain(50..100).collect::>() + ); } #[test] @@ -596,16 +612,16 @@ mod tests { tree.extend(rng.sample_iter(distributions::Standard).take(count), &()); for _ in 0..5 { - let splice_end = rng.gen_range(0..tree.extent::().0 + 1); + let splice_end = rng.gen_range(0..tree.extent::(&()).0 + 1); let splice_start = rng.gen_range(0..splice_end + 1); let count = rng.gen_range(0..3); - let tree_end = tree.extent::(); + let tree_end = tree.extent::(&()); let new_items = rng .sample_iter(distributions::Standard) .take(count) .collect::>(); - let mut reference_items = tree.items(); + let mut reference_items = tree.items(&()); reference_items.splice(splice_start..splice_end, new_items.clone()); tree = { @@ -617,11 +633,12 @@ mod tests { new_tree }; - assert_eq!(tree.items(), reference_items); + assert_eq!(tree.items(&()), reference_items); - let mut filter_cursor = tree.filter::<_, Count>(|summary| summary.contains_even); + let mut filter_cursor = + tree.filter::<_, Count>(|summary| summary.contains_even, &()); let mut reference_filter = tree - .items() + .items(&()) .into_iter() .enumerate() .filter(|(_, item)| (item & 1) == 0); @@ -629,11 +646,11 @@ mod tests { let (reference_index, reference_item) = reference_filter.next().unwrap(); assert_eq!(actual_item, &reference_item); assert_eq!(filter_cursor.start().0, reference_index); - filter_cursor.next(); + filter_cursor.next(&()); } assert!(reference_filter.next().is_none()); - let mut pos = rng.gen_range(0..tree.extent::().0 + 1); + let mut pos = rng.gen_range(0..tree.extent::(&()).0 + 1); let mut before_start = false; let mut cursor = tree.cursor::(); cursor.seek(&Count(pos), SeekBias::Right, &()); @@ -654,13 +671,13 @@ mod tests { } if i < 5 { - cursor.next(); + cursor.next(&()); if pos < reference_items.len() { pos += 1; before_start = false; } } else { - cursor.prev(); + cursor.prev(&()); if pos == 0 { before_start = true; } @@ -670,7 +687,7 @@ mod tests { } for _ in 0..10 { - let end = rng.gen_range(0..tree.extent::().0 + 1); + let end = rng.gen_range(0..tree.extent::(&()).0 + 1); let start = rng.gen_range(0..end + 1); let start_bias = if rng.gen() { SeekBias::Left @@ -701,7 +718,7 @@ mod tests { let tree = SumTree::::new(); let mut cursor = tree.cursor::(); assert_eq!( - cursor.slice(&Count(0), SeekBias::Right, &()).items(), + cursor.slice(&Count(0), SeekBias::Right, &()).items(&()), Vec::::new() ); assert_eq!(cursor.item(), None); @@ -713,25 +730,28 @@ mod tests { tree.extend(vec![1], &()); let mut cursor = tree.cursor::(); assert_eq!( - cursor.slice(&Count(0), SeekBias::Right, &()).items(), + cursor.slice(&Count(0), SeekBias::Right, &()).items(&()), Vec::::new() ); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.start(), &Sum(0)); - cursor.next(); + cursor.next(&()); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&1)); assert_eq!(cursor.start(), &Sum(1)); - cursor.prev(); + cursor.prev(&()); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.start(), &Sum(0)); let mut cursor = tree.cursor::(); - assert_eq!(cursor.slice(&Count(1), SeekBias::Right, &()).items(), [1]); + assert_eq!( + cursor.slice(&Count(1), SeekBias::Right, &()).items(&()), + [1] + ); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&1)); assert_eq!(cursor.start(), &Sum(1)); @@ -739,8 +759,8 @@ mod tests { cursor.seek(&Count(0), SeekBias::Right, &()); assert_eq!( cursor - .slice(&tree.extent::(), SeekBias::Right, &()) - .items(), + .slice(&tree.extent::(&()), SeekBias::Right, &()) + .items(&()), [1] ); assert_eq!(cursor.item(), None); @@ -753,70 +773,70 @@ mod tests { let mut cursor = tree.cursor::(); assert_eq!( - cursor.slice(&Count(2), SeekBias::Right, &()).items(), + cursor.slice(&Count(2), SeekBias::Right, &()).items(&()), [1, 2] ); assert_eq!(cursor.item(), Some(&3)); assert_eq!(cursor.prev_item(), Some(&2)); assert_eq!(cursor.start(), &Sum(3)); - cursor.next(); + cursor.next(&()); assert_eq!(cursor.item(), Some(&4)); assert_eq!(cursor.prev_item(), Some(&3)); assert_eq!(cursor.start(), &Sum(6)); - cursor.next(); + cursor.next(&()); assert_eq!(cursor.item(), Some(&5)); assert_eq!(cursor.prev_item(), Some(&4)); assert_eq!(cursor.start(), &Sum(10)); - cursor.next(); + cursor.next(&()); assert_eq!(cursor.item(), Some(&6)); assert_eq!(cursor.prev_item(), Some(&5)); assert_eq!(cursor.start(), &Sum(15)); - cursor.next(); - cursor.next(); + cursor.next(&()); + cursor.next(&()); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&6)); assert_eq!(cursor.start(), &Sum(21)); - cursor.prev(); + cursor.prev(&()); assert_eq!(cursor.item(), Some(&6)); assert_eq!(cursor.prev_item(), Some(&5)); assert_eq!(cursor.start(), &Sum(15)); - cursor.prev(); + cursor.prev(&()); assert_eq!(cursor.item(), Some(&5)); assert_eq!(cursor.prev_item(), Some(&4)); assert_eq!(cursor.start(), &Sum(10)); - cursor.prev(); + cursor.prev(&()); assert_eq!(cursor.item(), Some(&4)); assert_eq!(cursor.prev_item(), Some(&3)); assert_eq!(cursor.start(), &Sum(6)); - cursor.prev(); + cursor.prev(&()); assert_eq!(cursor.item(), Some(&3)); assert_eq!(cursor.prev_item(), Some(&2)); assert_eq!(cursor.start(), &Sum(3)); - cursor.prev(); + cursor.prev(&()); assert_eq!(cursor.item(), Some(&2)); assert_eq!(cursor.prev_item(), Some(&1)); assert_eq!(cursor.start(), &Sum(1)); - cursor.prev(); + cursor.prev(&()); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.start(), &Sum(0)); - cursor.prev(); + cursor.prev(&()); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.start(), &Sum(0)); - cursor.next(); + cursor.next(&()); assert_eq!(cursor.item(), Some(&1)); assert_eq!(cursor.prev_item(), None); assert_eq!(cursor.start(), &Sum(0)); @@ -824,9 +844,9 @@ mod tests { let mut cursor = tree.cursor::(); assert_eq!( cursor - .slice(&tree.extent::(), SeekBias::Right, &()) - .items(), - tree.items() + .slice(&tree.extent::(&()), SeekBias::Right, &()) + .items(&()), + tree.items(&()) ); assert_eq!(cursor.item(), None); assert_eq!(cursor.prev_item(), Some(&6)); @@ -835,8 +855,8 @@ mod tests { cursor.seek(&Count(3), SeekBias::Right, &()); assert_eq!( cursor - .slice(&tree.extent::(), SeekBias::Right, &()) - .items(), + .slice(&tree.extent::(&()), SeekBias::Right, &()) + .items(&()), [4, 5, 6] ); assert_eq!(cursor.item(), None); @@ -852,15 +872,15 @@ mod tests { // Slicing without resetting starts from where the cursor is parked at. cursor.seek(&Count(1), SeekBias::Right, &()); assert_eq!( - cursor.slice(&Count(3), SeekBias::Right, &()).items(), + cursor.slice(&Count(3), SeekBias::Right, &()).items(&()), vec![2, 3] ); assert_eq!( - cursor.slice(&Count(6), SeekBias::Left, &()).items(), + cursor.slice(&Count(6), SeekBias::Left, &()).items(&()), vec![4, 5] ); assert_eq!( - cursor.slice(&Count(6), SeekBias::Right, &()).items(), + cursor.slice(&Count(6), SeekBias::Right, &()).items(&()), vec![6] ); } @@ -870,7 +890,7 @@ mod tests { let mut tree = SumTree::::new(); let removed = tree.edit(vec![Edit::Insert(1), Edit::Insert(2), Edit::Insert(0)], &()); - assert_eq!(tree.items(), vec![0, 1, 2]); + assert_eq!(tree.items(&()), vec![0, 1, 2]); assert_eq!(removed, Vec::::new()); assert_eq!(tree.get(&0, &()), Some(&0)); assert_eq!(tree.get(&1, &()), Some(&1)); @@ -878,7 +898,7 @@ mod tests { assert_eq!(tree.get(&4, &()), None); let removed = tree.edit(vec![Edit::Insert(2), Edit::Insert(4), Edit::Remove(0)], &()); - assert_eq!(tree.items(), vec![1, 2, 4]); + assert_eq!(tree.items(&()), vec![1, 2, 4]); assert_eq!(removed, vec![0, 2]); assert_eq!(tree.get(&0, &()), None); assert_eq!(tree.get(&1, &()), Some(&1)); @@ -933,19 +953,19 @@ mod tests { } impl<'a> Dimension<'a, IntegersSummary> for u8 { - fn add_summary(&mut self, summary: &IntegersSummary) { + fn add_summary(&mut self, summary: &IntegersSummary, _: &()) { *self = summary.max; } } impl<'a> Dimension<'a, IntegersSummary> for Count { - fn add_summary(&mut self, summary: &IntegersSummary) { + fn add_summary(&mut self, summary: &IntegersSummary, _: &()) { self.0 += summary.count.0; } } impl<'a> Dimension<'a, IntegersSummary> for Sum { - fn add_summary(&mut self, summary: &IntegersSummary) { + fn add_summary(&mut self, summary: &IntegersSummary, _: &()) { self.0 += summary.sum.0; } } diff --git a/zed/src/sum_tree/cursor.rs b/zed/src/sum_tree/cursor.rs index 146683ec2c..e5515e45c2 100644 --- a/zed/src/sum_tree/cursor.rs +++ b/zed/src/sum_tree/cursor.rs @@ -49,10 +49,10 @@ where &self.sum_dimension } - pub fn end(&self) -> U { + pub fn end(&self, cx: &::Context) -> U { if let Some(item_summary) = self.item_summary() { let mut end = self.start().clone(); - end.add_summary(item_summary); + end.add_summary(item_summary, cx); end } else { self.start().clone() @@ -134,13 +134,13 @@ where } #[allow(unused)] - pub fn prev(&mut self) { + pub fn prev(&mut self, cx: &::Context) { assert!(self.did_seek, "Must seek before calling this method"); if self.at_end { self.seek_dimension = S::default(); self.sum_dimension = U::default(); - self.descend_to_last_item(self.tree); + self.descend_to_last_item(self.tree, cx); self.at_end = false; } else { while let Some(entry) = self.stack.pop() { @@ -167,8 +167,8 @@ where .. } => { for summary in &child_summaries[0..new_index] { - self.seek_dimension.add_summary(summary); - self.sum_dimension.add_summary(summary); + self.seek_dimension.add_summary(summary, cx); + self.sum_dimension.add_summary(summary, cx); } self.stack.push(StackEntry { tree: entry.tree, @@ -176,12 +176,12 @@ where seek_dimension: self.seek_dimension.clone(), sum_dimension: self.sum_dimension.clone(), }); - self.descend_to_last_item(&child_trees[new_index]); + self.descend_to_last_item(&child_trees[new_index], cx); } Node::Leaf { item_summaries, .. } => { for item_summary in &item_summaries[0..new_index] { - self.seek_dimension.add_summary(item_summary); - self.sum_dimension.add_summary(item_summary); + self.seek_dimension.add_summary(item_summary, cx); + self.sum_dimension.add_summary(item_summary, cx); } self.stack.push(StackEntry { tree: entry.tree, @@ -198,11 +198,11 @@ where } } - pub fn next(&mut self) { - self.next_internal(|_| true) + pub fn next(&mut self, cx: &::Context) { + self.next_internal(|_| true, cx) } - fn next_internal(&mut self, filter_node: F) + fn next_internal(&mut self, filter_node: F, cx: &::Context) where F: Fn(&T::Summary) -> bool, { @@ -230,8 +230,8 @@ where } => { if !descend { let summary = &child_summaries[entry.index]; - entry.seek_dimension.add_summary(summary); - entry.sum_dimension.add_summary(summary); + entry.seek_dimension.add_summary(summary, cx); + entry.sum_dimension.add_summary(summary, cx); entry.index += 1; } @@ -240,8 +240,8 @@ where if filter_node(next_summary) { break; } else { - self.seek_dimension.add_summary(next_summary); - self.sum_dimension.add_summary(next_summary); + self.seek_dimension.add_summary(next_summary, cx); + self.sum_dimension.add_summary(next_summary, cx); } entry.index += 1; } @@ -251,10 +251,10 @@ where Node::Leaf { item_summaries, .. } => { if !descend { let item_summary = &item_summaries[entry.index]; - self.seek_dimension.add_summary(item_summary); - entry.seek_dimension.add_summary(item_summary); - self.sum_dimension.add_summary(item_summary); - entry.sum_dimension.add_summary(item_summary); + self.seek_dimension.add_summary(item_summary, cx); + entry.seek_dimension.add_summary(item_summary, cx); + self.sum_dimension.add_summary(item_summary, cx); + entry.sum_dimension.add_summary(item_summary, cx); entry.index += 1; } @@ -263,10 +263,10 @@ where if filter_node(next_item_summary) { return; } else { - self.seek_dimension.add_summary(next_item_summary); - entry.seek_dimension.add_summary(next_item_summary); - self.sum_dimension.add_summary(next_item_summary); - entry.sum_dimension.add_summary(next_item_summary); + self.seek_dimension.add_summary(next_item_summary, cx); + entry.seek_dimension.add_summary(next_item_summary, cx); + self.sum_dimension.add_summary(next_item_summary, cx); + entry.sum_dimension.add_summary(next_item_summary, cx); entry.index += 1; } } else { @@ -295,7 +295,11 @@ where debug_assert!(self.stack.is_empty() || self.stack.last().unwrap().tree.0.is_leaf()); } - fn descend_to_last_item(&mut self, mut subtree: &'a SumTree) { + fn descend_to_last_item( + &mut self, + mut subtree: &'a SumTree, + cx: &::Context, + ) { self.did_seek = true; loop { match subtree.0.as_ref() { @@ -305,8 +309,8 @@ where .. } => { for summary in &child_summaries[0..child_summaries.len() - 1] { - self.seek_dimension.add_summary(summary); - self.sum_dimension.add_summary(summary); + self.seek_dimension.add_summary(summary, cx); + self.sum_dimension.add_summary(summary, cx); } self.stack.push(StackEntry { @@ -320,8 +324,8 @@ where Node::Leaf { item_summaries, .. } => { let last_index = item_summaries.len().saturating_sub(1); for item_summary in &item_summaries[0..last_index] { - self.seek_dimension.add_summary(item_summary); - self.sum_dimension.add_summary(item_summary); + self.seek_dimension.add_summary(item_summary, cx); + self.sum_dimension.add_summary(item_summary, cx); } self.stack.push(StackEntry { tree: subtree, @@ -372,7 +376,7 @@ where } pub fn suffix(&mut self, cx: &::Context) -> SumTree { - let extent = self.tree.extent::(); + let extent = self.tree.extent::(cx); let mut slice = SeekAggregate::Slice(SumTree::new()); self.seek_internal::<()>(&extent, SeekBias::Right, &mut slice, cx); if let SeekAggregate::Slice(slice) = slice { @@ -428,21 +432,21 @@ where .zip(&child_summaries[entry.index..]) { let mut child_end = self.seek_dimension.clone(); - child_end.add_summary(&child_summary); + child_end.add_summary(&child_summary, cx); let comparison = target.cmp(&child_end, cx); if comparison == Ordering::Greater || (comparison == Ordering::Equal && bias == SeekBias::Right) { self.seek_dimension = child_end; - self.sum_dimension.add_summary(child_summary); + self.sum_dimension.add_summary(child_summary, cx); match aggregate { SeekAggregate::None => {} SeekAggregate::Slice(slice) => { slice.push_tree(child_tree.clone(), cx); } SeekAggregate::Summary(summary) => { - summary.add_summary(child_summary); + summary.add_summary(child_summary, cx); } } entry.index += 1; @@ -470,14 +474,14 @@ where .zip(&item_summaries[entry.index..]) { let mut child_end = self.seek_dimension.clone(); - child_end.add_summary(item_summary); + child_end.add_summary(item_summary, cx); let comparison = target.cmp(&child_end, cx); if comparison == Ordering::Greater || (comparison == Ordering::Equal && bias == SeekBias::Right) { self.seek_dimension = child_end; - self.sum_dimension.add_summary(item_summary); + self.sum_dimension.add_summary(item_summary, cx); match aggregate { SeekAggregate::None => {} SeekAggregate::Slice(_) => { @@ -489,7 +493,7 @@ where .add_summary(item_summary, cx); } SeekAggregate::Summary(summary) => { - summary.add_summary(item_summary); + summary.add_summary(item_summary, cx); } } entry.index += 1; @@ -544,21 +548,21 @@ where child_trees.iter().zip(child_summaries).enumerate() { let mut child_end = self.seek_dimension.clone(); - child_end.add_summary(child_summary); + child_end.add_summary(child_summary, cx); let comparison = target.cmp(&child_end, cx); if comparison == Ordering::Greater || (comparison == Ordering::Equal && bias == SeekBias::Right) { self.seek_dimension = child_end; - self.sum_dimension.add_summary(child_summary); + self.sum_dimension.add_summary(child_summary, cx); match aggregate { SeekAggregate::None => {} SeekAggregate::Slice(slice) => { slice.push_tree(child_trees[index].clone(), cx); } SeekAggregate::Summary(summary) => { - summary.add_summary(child_summary); + summary.add_summary(child_summary, cx); } } } else { @@ -590,14 +594,14 @@ where items.iter().zip(item_summaries).enumerate() { let mut child_end = self.seek_dimension.clone(); - child_end.add_summary(item_summary); + child_end.add_summary(item_summary, cx); let comparison = target.cmp(&child_end, cx); if comparison == Ordering::Greater || (comparison == Ordering::Equal && bias == SeekBias::Right) { self.seek_dimension = child_end; - self.sum_dimension.add_summary(item_summary); + self.sum_dimension.add_summary(item_summary, cx); match aggregate { SeekAggregate::None => {} SeekAggregate::Slice(_) => { @@ -609,7 +613,7 @@ where slice_item_summaries.push(item_summary.clone()); } SeekAggregate::Summary(summary) => { - summary.add_summary(item_summary); + summary.add_summary(item_summary, cx); } } } else { @@ -651,7 +655,7 @@ where if bias == SeekBias::Left { let mut end = self.seek_dimension.clone(); if let Some(summary) = self.item_summary() { - end.add_summary(summary); + end.add_summary(summary, cx); } target.cmp(&end, cx) == Ordering::Equal } else { @@ -660,21 +664,22 @@ where } } -impl<'a, T, S, U> Iterator for Cursor<'a, T, S, U> +impl<'a, T, S, Seek, Sum> Iterator for Cursor<'a, T, Seek, Sum> where - T: Item, - S: Dimension<'a, T::Summary>, - U: Dimension<'a, T::Summary>, + T: Item, + S: Summary, + Seek: Dimension<'a, T::Summary>, + Sum: Dimension<'a, T::Summary>, { type Item = &'a T; fn next(&mut self) -> Option { if !self.did_seek { - self.next(); + self.next(&()); } if let Some(item) = self.item() { - self.next(); + self.next(&()); Some(item) } else { None @@ -693,9 +698,13 @@ where T: Item, U: Dimension<'a, T::Summary>, { - pub fn new(tree: &'a SumTree, filter_node: F) -> Self { + pub fn new( + tree: &'a SumTree, + filter_node: F, + cx: &::Context, + ) -> Self { let mut cursor = tree.cursor::<(), U>(); - cursor.next_internal(&filter_node); + cursor.next_internal(&filter_node, cx); Self { cursor, filter_node, @@ -710,22 +719,23 @@ where self.cursor.item() } - pub fn next(&mut self) { - self.cursor.next_internal(&self.filter_node); + pub fn next(&mut self, cx: &::Context) { + self.cursor.next_internal(&self.filter_node, cx); } } -impl<'a, F, T, U> Iterator for FilterCursor<'a, F, T, U> +impl<'a, F, T, S, U> Iterator for FilterCursor<'a, F, T, U> where F: Fn(&T::Summary) -> bool, - T: Item, + T: Item, + S: Summary, U: Dimension<'a, T::Summary>, { type Item = &'a T; fn next(&mut self) -> Option { if let Some(item) = self.item() { - self.cursor.next_internal(&self.filter_node); + self.cursor.next_internal(&self.filter_node, &()); Some(item) } else { None diff --git a/zed/src/worktree.rs b/zed/src/worktree.rs index f8bf316d54..56d53c0c5c 100644 --- a/zed/src/worktree.rs +++ b/zed/src/worktree.rs @@ -603,7 +603,7 @@ impl Default for PathKey { } impl<'a> sum_tree::Dimension<'a, EntrySummary> for PathKey { - fn add_summary(&mut self, summary: &'a EntrySummary) { + fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) { self.0 = summary.max_path.clone(); } } @@ -643,7 +643,7 @@ impl<'a> Default for PathSearch<'a> { } impl<'a: 'b, 'b> sum_tree::Dimension<'a, EntrySummary> for PathSearch<'b> { - fn add_summary(&mut self, summary: &'a EntrySummary) { + fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) { *self = Self::Exact(summary.max_path.as_ref()); } } @@ -652,7 +652,7 @@ impl<'a: 'b, 'b> sum_tree::Dimension<'a, EntrySummary> for PathSearch<'b> { pub struct FileCount(usize); impl<'a> sum_tree::Dimension<'a, EntrySummary> for FileCount { - fn add_summary(&mut self, summary: &'a EntrySummary) { + fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) { self.0 += summary.file_count; } } @@ -661,7 +661,7 @@ impl<'a> sum_tree::Dimension<'a, EntrySummary> for FileCount { pub struct VisibleFileCount(usize); impl<'a> sum_tree::Dimension<'a, EntrySummary> for VisibleFileCount { - fn add_summary(&mut self, summary: &'a EntrySummary) { + fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) { self.0 += summary.visible_file_count; } }