Detailed changes
@@ -343,8 +343,7 @@ impl BufferDiffInner {
..
} in hunks.iter().cloned()
{
- let preceding_pending_hunks =
- old_pending_hunks.slice(&buffer_range.start, Bias::Left, buffer);
+ let preceding_pending_hunks = old_pending_hunks.slice(&buffer_range.start, Bias::Left);
pending_hunks.append(preceding_pending_hunks, buffer);
// Skip all overlapping or adjacent old pending hunks
@@ -355,7 +354,7 @@ impl BufferDiffInner {
.cmp(&buffer_range.end, buffer)
.is_le()
}) {
- old_pending_hunks.next(buffer);
+ old_pending_hunks.next();
}
if (stage && secondary_status == DiffHunkSecondaryStatus::NoSecondaryHunk)
@@ -379,10 +378,10 @@ impl BufferDiffInner {
);
}
// append the remainder
- pending_hunks.append(old_pending_hunks.suffix(buffer), buffer);
+ pending_hunks.append(old_pending_hunks.suffix(), buffer);
let mut unstaged_hunk_cursor = unstaged_diff.hunks.cursor::<DiffHunkSummary>(buffer);
- unstaged_hunk_cursor.next(buffer);
+ unstaged_hunk_cursor.next();
// then, iterate over all pending hunks (both new ones and the existing ones) and compute the edits
let mut prev_unstaged_hunk_buffer_end = 0;
@@ -397,8 +396,7 @@ impl BufferDiffInner {
}) = pending_hunks_iter.next()
{
// Advance unstaged_hunk_cursor to skip unstaged hunks before current hunk
- let skipped_unstaged =
- unstaged_hunk_cursor.slice(&buffer_range.start, Bias::Left, buffer);
+ let skipped_unstaged = unstaged_hunk_cursor.slice(&buffer_range.start, Bias::Left);
if let Some(unstaged_hunk) = skipped_unstaged.last() {
prev_unstaged_hunk_base_text_end = unstaged_hunk.diff_base_byte_range.end;
@@ -425,7 +423,7 @@ impl BufferDiffInner {
buffer_offset_range.end =
buffer_offset_range.end.max(unstaged_hunk_offset_range.end);
- unstaged_hunk_cursor.next(buffer);
+ unstaged_hunk_cursor.next();
continue;
}
}
@@ -514,7 +512,7 @@ impl BufferDiffInner {
});
let anchor_iter = iter::from_fn(move || {
- cursor.next(buffer);
+ cursor.next();
cursor.item()
})
.flat_map(move |hunk| {
@@ -531,12 +529,12 @@ impl BufferDiffInner {
});
let mut pending_hunks_cursor = self.pending_hunks.cursor::<DiffHunkSummary>(buffer);
- pending_hunks_cursor.next(buffer);
+ pending_hunks_cursor.next();
let mut secondary_cursor = None;
if let Some(secondary) = secondary.as_ref() {
let mut cursor = secondary.hunks.cursor::<DiffHunkSummary>(buffer);
- cursor.next(buffer);
+ cursor.next();
secondary_cursor = Some(cursor);
}
@@ -564,7 +562,7 @@ impl BufferDiffInner {
.cmp(&pending_hunks_cursor.start().buffer_range.start, buffer)
.is_gt()
{
- pending_hunks_cursor.seek_forward(&start_anchor, Bias::Left, buffer);
+ pending_hunks_cursor.seek_forward(&start_anchor, Bias::Left);
}
if let Some(pending_hunk) = pending_hunks_cursor.item() {
@@ -590,7 +588,7 @@ impl BufferDiffInner {
.cmp(&secondary_cursor.start().buffer_range.start, buffer)
.is_gt()
{
- secondary_cursor.seek_forward(&start_anchor, Bias::Left, buffer);
+ secondary_cursor.seek_forward(&start_anchor, Bias::Left);
}
if let Some(secondary_hunk) = secondary_cursor.item() {
@@ -635,7 +633,7 @@ impl BufferDiffInner {
});
iter::from_fn(move || {
- cursor.prev(buffer);
+ cursor.prev();
let hunk = cursor.item()?;
let range = hunk.buffer_range.to_point(buffer);
@@ -653,8 +651,8 @@ impl BufferDiffInner {
fn compare(&self, old: &Self, new_snapshot: &text::BufferSnapshot) -> Option<Range<Anchor>> {
let mut new_cursor = self.hunks.cursor::<()>(new_snapshot);
let mut old_cursor = old.hunks.cursor::<()>(new_snapshot);
- old_cursor.next(new_snapshot);
- new_cursor.next(new_snapshot);
+ old_cursor.next();
+ new_cursor.next();
let mut start = None;
let mut end = None;
@@ -669,7 +667,7 @@ impl BufferDiffInner {
Ordering::Less => {
start.get_or_insert(new_hunk.buffer_range.start);
end.replace(new_hunk.buffer_range.end);
- new_cursor.next(new_snapshot);
+ new_cursor.next();
}
Ordering::Equal => {
if new_hunk != old_hunk {
@@ -686,25 +684,25 @@ impl BufferDiffInner {
}
}
- new_cursor.next(new_snapshot);
- old_cursor.next(new_snapshot);
+ new_cursor.next();
+ old_cursor.next();
}
Ordering::Greater => {
start.get_or_insert(old_hunk.buffer_range.start);
end.replace(old_hunk.buffer_range.end);
- old_cursor.next(new_snapshot);
+ old_cursor.next();
}
}
}
(Some(new_hunk), None) => {
start.get_or_insert(new_hunk.buffer_range.start);
end.replace(new_hunk.buffer_range.end);
- new_cursor.next(new_snapshot);
+ new_cursor.next();
}
(None, Some(old_hunk)) => {
start.get_or_insert(old_hunk.buffer_range.start);
end.replace(old_hunk.buffer_range.end);
- old_cursor.next(new_snapshot);
+ old_cursor.next();
}
(None, None) => break,
}
@@ -333,7 +333,7 @@ impl ChannelChat {
if first_id <= message_id {
let mut cursor = chat.messages.cursor::<(ChannelMessageId, Count)>(&());
let message_id = ChannelMessageId::Saved(message_id);
- cursor.seek(&message_id, Bias::Left, &());
+ cursor.seek(&message_id, Bias::Left);
return ControlFlow::Break(
if cursor
.item()
@@ -499,7 +499,7 @@ impl ChannelChat {
pub fn message(&self, ix: usize) -> &ChannelMessage {
let mut cursor = self.messages.cursor::<Count>(&());
- cursor.seek(&Count(ix), Bias::Right, &());
+ cursor.seek(&Count(ix), Bias::Right);
cursor.item().unwrap()
}
@@ -516,13 +516,13 @@ impl ChannelChat {
pub fn messages_in_range(&self, range: Range<usize>) -> impl Iterator<Item = &ChannelMessage> {
let mut cursor = self.messages.cursor::<Count>(&());
- cursor.seek(&Count(range.start), Bias::Right, &());
+ cursor.seek(&Count(range.start), Bias::Right);
cursor.take(range.len())
}
pub fn pending_messages(&self) -> impl Iterator<Item = &ChannelMessage> {
let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
- cursor.seek(&ChannelMessageId::Pending(0), Bias::Left, &());
+ cursor.seek(&ChannelMessageId::Pending(0), Bias::Left);
cursor
}
@@ -588,9 +588,9 @@ impl ChannelChat {
.collect::<HashSet<_>>();
let mut old_cursor = self.messages.cursor::<(ChannelMessageId, Count)>(&());
- let mut new_messages = old_cursor.slice(&first_message.id, Bias::Left, &());
+ let mut new_messages = old_cursor.slice(&first_message.id, Bias::Left);
let start_ix = old_cursor.start().1.0;
- let removed_messages = old_cursor.slice(&last_message.id, Bias::Right, &());
+ let removed_messages = old_cursor.slice(&last_message.id, Bias::Right);
let removed_count = removed_messages.summary().count;
let new_count = messages.summary().count;
let end_ix = start_ix + removed_count;
@@ -599,10 +599,10 @@ impl ChannelChat {
let mut ranges = Vec::<Range<usize>>::new();
if new_messages.last().unwrap().is_pending() {
- new_messages.append(old_cursor.suffix(&()), &());
+ new_messages.append(old_cursor.suffix(), &());
} else {
new_messages.append(
- old_cursor.slice(&ChannelMessageId::Pending(0), Bias::Left, &()),
+ old_cursor.slice(&ChannelMessageId::Pending(0), Bias::Left),
&(),
);
@@ -617,7 +617,7 @@ impl ChannelChat {
} else {
new_messages.push(message.clone(), &());
}
- old_cursor.next(&());
+ old_cursor.next();
}
}
@@ -641,12 +641,12 @@ impl ChannelChat {
fn message_removed(&mut self, id: u64, cx: &mut Context<Self>) {
let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
- let mut messages = cursor.slice(&ChannelMessageId::Saved(id), Bias::Left, &());
+ let mut messages = cursor.slice(&ChannelMessageId::Saved(id), Bias::Left);
if let Some(item) = cursor.item() {
if item.id == ChannelMessageId::Saved(id) {
let deleted_message_ix = messages.summary().count;
- cursor.next(&());
- messages.append(cursor.suffix(&()), &());
+ cursor.next();
+ messages.append(cursor.suffix(), &());
drop(cursor);
self.messages = messages;
@@ -680,7 +680,7 @@ impl ChannelChat {
cx: &mut Context<Self>,
) {
let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
- let mut messages = cursor.slice(&id, Bias::Left, &());
+ let mut messages = cursor.slice(&id, Bias::Left);
let ix = messages.summary().count;
if let Some(mut message_to_update) = cursor.item().cloned() {
@@ -688,10 +688,10 @@ impl ChannelChat {
message_to_update.mentions = mentions;
message_to_update.edited_at = edited_at;
messages.push(message_to_update, &());
- cursor.next(&());
+ cursor.next();
}
- messages.append(cursor.suffix(&()), &());
+ messages.append(cursor.suffix(), &());
drop(cursor);
self.messages = messages;
@@ -524,10 +524,10 @@ impl BlockMap {
// * Isomorphic transforms that end *at* the start of the edit
// * Below blocks that end at the start of the edit
// However, if we hit a replace block that ends at the start of the edit we want to reconstruct it.
- new_transforms.append(cursor.slice(&old_start, Bias::Left, &()), &());
+ new_transforms.append(cursor.slice(&old_start, Bias::Left), &());
if let Some(transform) = cursor.item() {
if transform.summary.input_rows > 0
- && cursor.end(&()) == old_start
+ && cursor.end() == old_start
&& transform
.block
.as_ref()
@@ -535,13 +535,13 @@ impl BlockMap {
{
// Preserve the transform (push and next)
new_transforms.push(transform.clone(), &());
- cursor.next(&());
+ cursor.next();
// Preserve below blocks at end of edit
while let Some(transform) = cursor.item() {
if transform.block.as_ref().map_or(false, |b| b.place_below()) {
new_transforms.push(transform.clone(), &());
- cursor.next(&());
+ cursor.next();
} else {
break;
}
@@ -579,8 +579,8 @@ impl BlockMap {
let mut new_end = WrapRow(edit.new.end);
loop {
// Seek to the transform starting at or after the end of the edit
- cursor.seek(&old_end, Bias::Left, &());
- cursor.next(&());
+ cursor.seek(&old_end, Bias::Left);
+ cursor.next();
// Extend edit to the end of the discarded transform so it is reconstructed in full
let transform_rows_after_edit = cursor.start().0 - old_end.0;
@@ -592,8 +592,8 @@ impl BlockMap {
if next_edit.old.start <= cursor.start().0 {
old_end = WrapRow(next_edit.old.end);
new_end = WrapRow(next_edit.new.end);
- cursor.seek(&old_end, Bias::Left, &());
- cursor.next(&());
+ cursor.seek(&old_end, Bias::Left);
+ cursor.next();
edits.next();
} else {
break;
@@ -608,7 +608,7 @@ impl BlockMap {
// Discard below blocks at the end of the edit. They'll be reconstructed.
while let Some(transform) = cursor.item() {
if transform.block.as_ref().map_or(false, |b| b.place_below()) {
- cursor.next(&());
+ cursor.next();
} else {
break;
}
@@ -720,7 +720,7 @@ impl BlockMap {
push_isomorphic(&mut new_transforms, rows_after_last_block, wrap_snapshot);
}
- new_transforms.append(cursor.suffix(&()), &());
+ new_transforms.append(cursor.suffix(), &());
debug_assert_eq!(
new_transforms.summary().input_rows,
wrap_snapshot.max_point().row() + 1
@@ -971,7 +971,7 @@ impl BlockMapReader<'_> {
);
let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
- cursor.seek(&start_wrap_row, Bias::Left, &());
+ cursor.seek(&start_wrap_row, Bias::Left);
while let Some(transform) = cursor.item() {
if cursor.start().0 > end_wrap_row {
break;
@@ -982,7 +982,7 @@ impl BlockMapReader<'_> {
return Some(cursor.start().1);
}
}
- cursor.next(&());
+ cursor.next();
}
None
@@ -1293,7 +1293,7 @@ impl BlockSnapshot {
let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows);
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
- cursor.seek(&BlockRow(rows.start), Bias::Right, &());
+ cursor.seek(&BlockRow(rows.start), Bias::Right);
let transform_output_start = cursor.start().0.0;
let transform_input_start = cursor.start().1.0;
@@ -1325,7 +1325,7 @@ impl BlockSnapshot {
pub(super) fn row_infos(&self, start_row: BlockRow) -> BlockRows<'_> {
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
- cursor.seek(&start_row, Bias::Right, &());
+ cursor.seek(&start_row, Bias::Right);
let (output_start, input_start) = cursor.start();
let overshoot = if cursor
.item()
@@ -1346,9 +1346,9 @@ impl BlockSnapshot {
pub fn blocks_in_range(&self, rows: Range<u32>) -> impl Iterator<Item = (u32, &Block)> {
let mut cursor = self.transforms.cursor::<BlockRow>(&());
- cursor.seek(&BlockRow(rows.start), Bias::Left, &());
- while cursor.start().0 < rows.start && cursor.end(&()).0 <= rows.start {
- cursor.next(&());
+ cursor.seek(&BlockRow(rows.start), Bias::Left);
+ while cursor.start().0 < rows.start && cursor.end().0 <= rows.start {
+ cursor.next();
}
std::iter::from_fn(move || {
@@ -1364,10 +1364,10 @@ impl BlockSnapshot {
break;
}
if let Some(block) = &transform.block {
- cursor.next(&());
+ cursor.next();
return Some((start_row, block));
} else {
- cursor.next(&());
+ cursor.next();
}
}
None
@@ -1377,7 +1377,7 @@ impl BlockSnapshot {
pub fn sticky_header_excerpt(&self, position: f32) -> Option<StickyHeaderExcerpt<'_>> {
let top_row = position as u32;
let mut cursor = self.transforms.cursor::<BlockRow>(&());
- cursor.seek(&BlockRow(top_row), Bias::Right, &());
+ cursor.seek(&BlockRow(top_row), Bias::Right);
while let Some(transform) = cursor.item() {
match &transform.block {
@@ -1386,7 +1386,7 @@ impl BlockSnapshot {
}
Some(block) if block.is_buffer_header() => return None,
_ => {
- cursor.prev(&());
+ cursor.prev();
continue;
}
}
@@ -1414,7 +1414,7 @@ impl BlockSnapshot {
let wrap_row = WrapRow(wrap_point.row());
let mut cursor = self.transforms.cursor::<WrapRow>(&());
- cursor.seek(&wrap_row, Bias::Left, &());
+ cursor.seek(&wrap_row, Bias::Left);
while let Some(transform) = cursor.item() {
if let Some(block) = transform.block.as_ref() {
@@ -1425,7 +1425,7 @@ impl BlockSnapshot {
break;
}
- cursor.next(&());
+ cursor.next();
}
None
@@ -1442,7 +1442,7 @@ impl BlockSnapshot {
pub fn longest_row_in_range(&self, range: Range<BlockRow>) -> BlockRow {
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
- cursor.seek(&range.start, Bias::Right, &());
+ cursor.seek(&range.start, Bias::Right);
let mut longest_row = range.start;
let mut longest_row_chars = 0;
@@ -1453,7 +1453,7 @@ impl BlockSnapshot {
let wrap_start_row = input_start.0 + overshoot;
let wrap_end_row = cmp::min(
input_start.0 + (range.end.0 - output_start.0),
- cursor.end(&()).1.0,
+ cursor.end().1.0,
);
let summary = self
.wrap_snapshot
@@ -1461,12 +1461,12 @@ impl BlockSnapshot {
longest_row = BlockRow(range.start.0 + summary.longest_row);
longest_row_chars = summary.longest_row_chars;
}
- cursor.next(&());
+ cursor.next();
}
let cursor_start_row = cursor.start().0;
if range.end > cursor_start_row {
- let summary = cursor.summary::<_, TransformSummary>(&range.end, Bias::Right, &());
+ let summary = cursor.summary::<_, TransformSummary>(&range.end, Bias::Right);
if summary.longest_row_chars > longest_row_chars {
longest_row = BlockRow(cursor_start_row.0 + summary.longest_row);
longest_row_chars = summary.longest_row_chars;
@@ -1493,7 +1493,7 @@ impl BlockSnapshot {
pub(super) fn line_len(&self, row: BlockRow) -> u32 {
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
- cursor.seek(&BlockRow(row.0), Bias::Right, &());
+ cursor.seek(&BlockRow(row.0), Bias::Right);
if let Some(transform) = cursor.item() {
let (output_start, input_start) = cursor.start();
let overshoot = row.0 - output_start.0;
@@ -1511,13 +1511,13 @@ impl BlockSnapshot {
pub(super) fn is_block_line(&self, row: BlockRow) -> bool {
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
- cursor.seek(&row, Bias::Right, &());
+ cursor.seek(&row, Bias::Right);
cursor.item().map_or(false, |t| t.block.is_some())
}
pub(super) fn is_folded_buffer_header(&self, row: BlockRow) -> bool {
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
- cursor.seek(&row, Bias::Right, &());
+ cursor.seek(&row, Bias::Right);
let Some(transform) = cursor.item() else {
return false;
};
@@ -1529,7 +1529,7 @@ impl BlockSnapshot {
.wrap_snapshot
.make_wrap_point(Point::new(row.0, 0), Bias::Left);
let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
- cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &());
+ cursor.seek(&WrapRow(wrap_point.row()), Bias::Right);
cursor.item().map_or(false, |transform| {
transform
.block
@@ -1540,17 +1540,17 @@ impl BlockSnapshot {
pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
- cursor.seek(&BlockRow(point.row), Bias::Right, &());
+ cursor.seek(&BlockRow(point.row), Bias::Right);
let max_input_row = WrapRow(self.transforms.summary().input_rows);
let mut search_left =
- (bias == Bias::Left && cursor.start().1.0 > 0) || cursor.end(&()).1 == max_input_row;
+ (bias == Bias::Left && cursor.start().1.0 > 0) || cursor.end().1 == max_input_row;
let mut reversed = false;
loop {
if let Some(transform) = cursor.item() {
let (output_start_row, input_start_row) = cursor.start();
- let (output_end_row, input_end_row) = cursor.end(&());
+ let (output_end_row, input_end_row) = cursor.end();
let output_start = Point::new(output_start_row.0, 0);
let input_start = Point::new(input_start_row.0, 0);
let input_end = Point::new(input_end_row.0, 0);
@@ -1584,23 +1584,23 @@ impl BlockSnapshot {
}
if search_left {
- cursor.prev(&());
+ cursor.prev();
} else {
- cursor.next(&());
+ cursor.next();
}
} else if reversed {
return self.max_point();
} else {
reversed = true;
search_left = !search_left;
- cursor.seek(&BlockRow(point.row), Bias::Right, &());
+ cursor.seek(&BlockRow(point.row), Bias::Right);
}
}
}
pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint {
let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
- cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &());
+ cursor.seek(&WrapRow(wrap_point.row()), Bias::Right);
if let Some(transform) = cursor.item() {
if transform.block.is_some() {
BlockPoint::new(cursor.start().1.0, 0)
@@ -1618,7 +1618,7 @@ impl BlockSnapshot {
pub fn to_wrap_point(&self, block_point: BlockPoint, bias: Bias) -> WrapPoint {
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
- cursor.seek(&BlockRow(block_point.row), Bias::Right, &());
+ cursor.seek(&BlockRow(block_point.row), Bias::Right);
if let Some(transform) = cursor.item() {
match transform.block.as_ref() {
Some(block) => {
@@ -1630,7 +1630,7 @@ impl BlockSnapshot {
} else if bias == Bias::Left {
WrapPoint::new(cursor.start().1.0, 0)
} else {
- let wrap_row = cursor.end(&()).1.0 - 1;
+ let wrap_row = cursor.end().1.0 - 1;
WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
}
}
@@ -1650,14 +1650,14 @@ impl BlockChunks<'_> {
/// Go to the next transform
fn advance(&mut self) {
self.input_chunk = Chunk::default();
- self.transforms.next(&());
+ self.transforms.next();
while let Some(transform) = self.transforms.item() {
if transform
.block
.as_ref()
.map_or(false, |block| block.height() == 0)
{
- self.transforms.next(&());
+ self.transforms.next();
} else {
break;
}
@@ -1672,7 +1672,7 @@ impl BlockChunks<'_> {
let start_output_row = self.transforms.start().0.0;
if start_output_row < self.max_output_row {
let end_input_row = cmp::min(
- self.transforms.end(&()).1.0,
+ self.transforms.end().1.0,
start_input_row + (self.max_output_row - start_output_row),
);
self.input_chunks.seek(start_input_row..end_input_row);
@@ -1696,7 +1696,7 @@ impl<'a> Iterator for BlockChunks<'a> {
let transform = self.transforms.item()?;
if transform.block.is_some() {
let block_start = self.transforms.start().0.0;
- let mut block_end = self.transforms.end(&()).0.0;
+ let mut block_end = self.transforms.end().0.0;
self.advance();
if self.transforms.item().is_none() {
block_end -= 1;
@@ -1731,7 +1731,7 @@ impl<'a> Iterator for BlockChunks<'a> {
}
}
- let transform_end = self.transforms.end(&()).0.0;
+ let transform_end = self.transforms.end().0.0;
let (prefix_rows, prefix_bytes) =
offset_for_row(self.input_chunk.text, transform_end - self.output_row);
self.output_row += prefix_rows;
@@ -1770,15 +1770,15 @@ impl Iterator for BlockRows<'_> {
self.started = true;
}
- if self.output_row.0 >= self.transforms.end(&()).0.0 {
- self.transforms.next(&());
+ if self.output_row.0 >= self.transforms.end().0.0 {
+ self.transforms.next();
while let Some(transform) = self.transforms.item() {
if transform
.block
.as_ref()
.map_or(false, |block| block.height() == 0)
{
- self.transforms.next(&());
+ self.transforms.next();
} else {
break;
}
@@ -52,15 +52,15 @@ impl CreaseSnapshot {
) -> Option<&'a Crease<Anchor>> {
let start = snapshot.anchor_before(Point::new(row.0, 0));
let mut cursor = self.creases.cursor::<ItemSummary>(snapshot);
- cursor.seek(&start, Bias::Left, snapshot);
+ cursor.seek(&start, Bias::Left);
while let Some(item) = cursor.item() {
match Ord::cmp(&item.crease.range().start.to_point(snapshot).row, &row.0) {
- Ordering::Less => cursor.next(snapshot),
+ Ordering::Less => cursor.next(),
Ordering::Equal => {
if item.crease.range().start.is_valid(snapshot) {
return Some(&item.crease);
} else {
- cursor.next(snapshot);
+ cursor.next();
}
}
Ordering::Greater => break,
@@ -76,11 +76,11 @@ impl CreaseSnapshot {
) -> impl 'a + Iterator<Item = &'a Crease<Anchor>> {
let start = snapshot.anchor_before(Point::new(range.start.0, 0));
let mut cursor = self.creases.cursor::<ItemSummary>(snapshot);
- cursor.seek(&start, Bias::Left, snapshot);
+ cursor.seek(&start, Bias::Left);
std::iter::from_fn(move || {
while let Some(item) = cursor.item() {
- cursor.next(snapshot);
+ cursor.next();
let crease_range = item.crease.range();
let crease_start = crease_range.start.to_point(snapshot);
let crease_end = crease_range.end.to_point(snapshot);
@@ -102,13 +102,13 @@ impl CreaseSnapshot {
let mut cursor = self.creases.cursor::<ItemSummary>(snapshot);
let mut results = Vec::new();
- cursor.next(snapshot);
+ cursor.next();
while let Some(item) = cursor.item() {
let crease_range = item.crease.range();
let start_point = crease_range.start.to_point(snapshot);
let end_point = crease_range.end.to_point(snapshot);
results.push((item.id, start_point..end_point));
- cursor.next(snapshot);
+ cursor.next();
}
results
@@ -298,7 +298,7 @@ impl CreaseMap {
let mut cursor = self.snapshot.creases.cursor::<ItemSummary>(snapshot);
for crease in creases {
let crease_range = crease.range().clone();
- new_creases.append(cursor.slice(&crease_range, Bias::Left, snapshot), snapshot);
+ new_creases.append(cursor.slice(&crease_range, Bias::Left), snapshot);
let id = self.next_id;
self.next_id.0 += 1;
@@ -306,7 +306,7 @@ impl CreaseMap {
new_creases.push(CreaseItem { crease, id }, snapshot);
new_ids.push(id);
}
- new_creases.append(cursor.suffix(snapshot), snapshot);
+ new_creases.append(cursor.suffix(), snapshot);
new_creases
};
new_ids
@@ -332,9 +332,9 @@ impl CreaseMap {
let mut cursor = self.snapshot.creases.cursor::<ItemSummary>(snapshot);
for (id, range) in &removals {
- new_creases.append(cursor.slice(range, Bias::Left, snapshot), snapshot);
+ new_creases.append(cursor.slice(range, Bias::Left), snapshot);
while let Some(item) = cursor.item() {
- cursor.next(snapshot);
+ cursor.next();
if item.id == *id {
break;
} else {
@@ -343,7 +343,7 @@ impl CreaseMap {
}
}
- new_creases.append(cursor.suffix(snapshot), snapshot);
+ new_creases.append(cursor.suffix(), snapshot);
new_creases
};
@@ -99,7 +99,7 @@ impl FoldPoint {
pub fn to_inlay_point(self, snapshot: &FoldSnapshot) -> InlayPoint {
let mut cursor = snapshot.transforms.cursor::<(FoldPoint, InlayPoint)>(&());
- cursor.seek(&self, Bias::Right, &());
+ cursor.seek(&self, Bias::Right);
let overshoot = self.0 - cursor.start().0.0;
InlayPoint(cursor.start().1.0 + overshoot)
}
@@ -108,7 +108,7 @@ impl FoldPoint {
let mut cursor = snapshot
.transforms
.cursor::<(FoldPoint, TransformSummary)>(&());
- cursor.seek(&self, Bias::Right, &());
+ cursor.seek(&self, Bias::Right);
let overshoot = self.0 - cursor.start().1.output.lines;
let mut offset = cursor.start().1.output.len;
if !overshoot.is_zero() {
@@ -187,10 +187,10 @@ impl FoldMapWriter<'_> {
width: None,
},
);
- new_tree.append(cursor.slice(&fold.range, Bias::Right, buffer), buffer);
+ new_tree.append(cursor.slice(&fold.range, Bias::Right), buffer);
new_tree.push(fold, buffer);
}
- new_tree.append(cursor.suffix(buffer), buffer);
+ new_tree.append(cursor.suffix(), buffer);
new_tree
};
@@ -252,7 +252,7 @@ impl FoldMapWriter<'_> {
fold_ixs_to_delete.push(*folds_cursor.start());
self.0.snapshot.fold_metadata_by_id.remove(&fold.id);
}
- folds_cursor.next(buffer);
+ folds_cursor.next();
}
}
@@ -263,10 +263,10 @@ impl FoldMapWriter<'_> {
let mut cursor = self.0.snapshot.folds.cursor::<usize>(buffer);
let mut folds = SumTree::new(buffer);
for fold_ix in fold_ixs_to_delete {
- folds.append(cursor.slice(&fold_ix, Bias::Right, buffer), buffer);
- cursor.next(buffer);
+ folds.append(cursor.slice(&fold_ix, Bias::Right), buffer);
+ cursor.next();
}
- folds.append(cursor.suffix(buffer), buffer);
+ folds.append(cursor.suffix(), buffer);
folds
};
@@ -412,7 +412,7 @@ impl FoldMap {
let mut new_transforms = SumTree::<Transform>::default();
let mut cursor = self.snapshot.transforms.cursor::<InlayOffset>(&());
- cursor.seek(&InlayOffset(0), Bias::Right, &());
+ cursor.seek(&InlayOffset(0), Bias::Right);
while let Some(mut edit) = inlay_edits_iter.next() {
if let Some(item) = cursor.item() {
@@ -421,19 +421,19 @@ impl FoldMap {
|transform| {
if !transform.is_fold() {
transform.summary.add_summary(&item.summary, &());
- cursor.next(&());
+ cursor.next();
}
},
&(),
);
}
}
- new_transforms.append(cursor.slice(&edit.old.start, Bias::Left, &()), &());
+ new_transforms.append(cursor.slice(&edit.old.start, Bias::Left), &());
edit.new.start -= edit.old.start - *cursor.start();
edit.old.start = *cursor.start();
- cursor.seek(&edit.old.end, Bias::Right, &());
- cursor.next(&());
+ cursor.seek(&edit.old.end, Bias::Right);
+ cursor.next();
let mut delta = edit.new_len().0 as isize - edit.old_len().0 as isize;
loop {
@@ -449,8 +449,8 @@ impl FoldMap {
if next_edit.old.end >= edit.old.end {
edit.old.end = next_edit.old.end;
- cursor.seek(&edit.old.end, Bias::Right, &());
- cursor.next(&());
+ cursor.seek(&edit.old.end, Bias::Right);
+ cursor.next();
}
} else {
break;
@@ -467,11 +467,7 @@ impl FoldMap {
.snapshot
.folds
.cursor::<FoldRange>(&inlay_snapshot.buffer);
- folds_cursor.seek(
- &FoldRange(anchor..Anchor::max()),
- Bias::Left,
- &inlay_snapshot.buffer,
- );
+ folds_cursor.seek(&FoldRange(anchor..Anchor::max()), Bias::Left);
let mut folds = iter::from_fn({
let inlay_snapshot = &inlay_snapshot;
@@ -485,7 +481,7 @@ impl FoldMap {
..inlay_snapshot.to_inlay_offset(buffer_end),
)
});
- folds_cursor.next(&inlay_snapshot.buffer);
+ folds_cursor.next();
item
}
})
@@ -558,7 +554,7 @@ impl FoldMap {
}
}
- new_transforms.append(cursor.suffix(&()), &());
+ new_transforms.append(cursor.suffix(), &());
if new_transforms.is_empty() {
let text_summary = inlay_snapshot.text_summary();
push_isomorphic(&mut new_transforms, text_summary);
@@ -575,31 +571,31 @@ impl FoldMap {
let mut new_transforms = new_transforms.cursor::<(InlayOffset, FoldOffset)>(&());
for mut edit in inlay_edits {
- old_transforms.seek(&edit.old.start, Bias::Left, &());
+ old_transforms.seek(&edit.old.start, Bias::Left);
if old_transforms.item().map_or(false, |t| t.is_fold()) {
edit.old.start = old_transforms.start().0;
}
let old_start =
old_transforms.start().1.0 + (edit.old.start - old_transforms.start().0).0;
- old_transforms.seek_forward(&edit.old.end, Bias::Right, &());
+ old_transforms.seek_forward(&edit.old.end, Bias::Right);
if old_transforms.item().map_or(false, |t| t.is_fold()) {
- old_transforms.next(&());
+ old_transforms.next();
edit.old.end = old_transforms.start().0;
}
let old_end =
old_transforms.start().1.0 + (edit.old.end - old_transforms.start().0).0;
- new_transforms.seek(&edit.new.start, Bias::Left, &());
+ new_transforms.seek(&edit.new.start, Bias::Left);
if new_transforms.item().map_or(false, |t| t.is_fold()) {
edit.new.start = new_transforms.start().0;
}
let new_start =
new_transforms.start().1.0 + (edit.new.start - new_transforms.start().0).0;
- new_transforms.seek_forward(&edit.new.end, Bias::Right, &());
+ new_transforms.seek_forward(&edit.new.end, Bias::Right);
if new_transforms.item().map_or(false, |t| t.is_fold()) {
- new_transforms.next(&());
+ new_transforms.next();
edit.new.end = new_transforms.start().0;
}
let new_end =
@@ -656,10 +652,10 @@ impl FoldSnapshot {
let mut summary = TextSummary::default();
let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&());
- cursor.seek(&range.start, Bias::Right, &());
+ cursor.seek(&range.start, Bias::Right);
if let Some(transform) = cursor.item() {
let start_in_transform = range.start.0 - cursor.start().0.0;
- let end_in_transform = cmp::min(range.end, cursor.end(&()).0).0 - cursor.start().0.0;
+ let end_in_transform = cmp::min(range.end, cursor.end().0).0 - cursor.start().0.0;
if let Some(placeholder) = transform.placeholder.as_ref() {
summary = TextSummary::from(
&placeholder.text
@@ -678,10 +674,10 @@ impl FoldSnapshot {
}
}
- if range.end > cursor.end(&()).0 {
- cursor.next(&());
+ if range.end > cursor.end().0 {
+ cursor.next();
summary += &cursor
- .summary::<_, TransformSummary>(&range.end, Bias::Right, &())
+ .summary::<_, TransformSummary>(&range.end, Bias::Right)
.output;
if let Some(transform) = cursor.item() {
let end_in_transform = range.end.0 - cursor.start().0.0;
@@ -705,19 +701,16 @@ impl FoldSnapshot {
pub fn to_fold_point(&self, point: InlayPoint, bias: Bias) -> FoldPoint {
let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
if cursor.item().map_or(false, |t| t.is_fold()) {
if bias == Bias::Left || point == cursor.start().0 {
cursor.start().1
} else {
- cursor.end(&()).1
+ cursor.end().1
}
} else {
let overshoot = point.0 - cursor.start().0.0;
- FoldPoint(cmp::min(
- cursor.start().1.0 + overshoot,
- cursor.end(&()).1.0,
- ))
+ FoldPoint(cmp::min(cursor.start().1.0 + overshoot, cursor.end().1.0))
}
}
@@ -742,7 +735,7 @@ impl FoldSnapshot {
let fold_point = FoldPoint::new(start_row, 0);
let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&());
- cursor.seek(&fold_point, Bias::Left, &());
+ cursor.seek(&fold_point, Bias::Left);
let overshoot = fold_point.0 - cursor.start().0.0;
let inlay_point = InlayPoint(cursor.start().1.0 + overshoot);
@@ -773,7 +766,7 @@ impl FoldSnapshot {
let mut folds = intersecting_folds(&self.inlay_snapshot, &self.folds, range, false);
iter::from_fn(move || {
let item = folds.item();
- folds.next(&self.inlay_snapshot.buffer);
+ folds.next();
item
})
}
@@ -785,7 +778,7 @@ impl FoldSnapshot {
let buffer_offset = offset.to_offset(&self.inlay_snapshot.buffer);
let inlay_offset = self.inlay_snapshot.to_inlay_offset(buffer_offset);
let mut cursor = self.transforms.cursor::<InlayOffset>(&());
- cursor.seek(&inlay_offset, Bias::Right, &());
+ cursor.seek(&inlay_offset, Bias::Right);
cursor.item().map_or(false, |t| t.placeholder.is_some())
}
@@ -794,7 +787,7 @@ impl FoldSnapshot {
.inlay_snapshot
.to_inlay_point(Point::new(buffer_row.0, 0));
let mut cursor = self.transforms.cursor::<InlayPoint>(&());
- cursor.seek(&inlay_point, Bias::Right, &());
+ cursor.seek(&inlay_point, Bias::Right);
loop {
match cursor.item() {
Some(transform) => {
@@ -808,11 +801,11 @@ impl FoldSnapshot {
None => return false,
}
- if cursor.end(&()).row() == inlay_point.row() {
- cursor.next(&());
+ if cursor.end().row() == inlay_point.row() {
+ cursor.next();
} else {
inlay_point.0 += Point::new(1, 0);
- cursor.seek(&inlay_point, Bias::Right, &());
+ cursor.seek(&inlay_point, Bias::Right);
}
}
}
@@ -824,14 +817,14 @@ impl FoldSnapshot {
highlights: Highlights<'a>,
) -> FoldChunks<'a> {
let mut transform_cursor = self.transforms.cursor::<(FoldOffset, InlayOffset)>(&());
- transform_cursor.seek(&range.start, Bias::Right, &());
+ transform_cursor.seek(&range.start, Bias::Right);
let inlay_start = {
let overshoot = range.start.0 - transform_cursor.start().0.0;
transform_cursor.start().1 + InlayOffset(overshoot)
};
- let transform_end = transform_cursor.end(&());
+ let transform_end = transform_cursor.end();
let inlay_end = if transform_cursor
.item()
@@ -879,14 +872,14 @@ impl FoldSnapshot {
pub fn clip_point(&self, point: FoldPoint, bias: Bias) -> FoldPoint {
let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
if let Some(transform) = cursor.item() {
let transform_start = cursor.start().0.0;
if transform.placeholder.is_some() {
if point.0 == transform_start || matches!(bias, Bias::Left) {
FoldPoint(transform_start)
} else {
- FoldPoint(cursor.end(&()).0.0)
+ FoldPoint(cursor.end().0.0)
}
} else {
let overshoot = InlayPoint(point.0 - transform_start);
@@ -945,7 +938,7 @@ fn intersecting_folds<'a>(
start_cmp == Ordering::Less && end_cmp == Ordering::Greater
}
});
- cursor.next(buffer);
+ cursor.next();
cursor
}
@@ -1211,7 +1204,7 @@ pub struct FoldRows<'a> {
impl FoldRows<'_> {
pub(crate) fn seek(&mut self, row: u32) {
let fold_point = FoldPoint::new(row, 0);
- self.cursor.seek(&fold_point, Bias::Left, &());
+ self.cursor.seek(&fold_point, Bias::Left);
let overshoot = fold_point.0 - self.cursor.start().0.0;
let inlay_point = InlayPoint(self.cursor.start().1.0 + overshoot);
self.input_rows.seek(inlay_point.row());
@@ -1224,8 +1217,8 @@ impl Iterator for FoldRows<'_> {
fn next(&mut self) -> Option<Self::Item> {
let mut traversed_fold = false;
- while self.fold_point > self.cursor.end(&()).0 {
- self.cursor.next(&());
+ while self.fold_point > self.cursor.end().0 {
+ self.cursor.next();
traversed_fold = true;
if self.cursor.item().is_none() {
break;
@@ -1330,14 +1323,14 @@ pub struct FoldChunks<'a> {
impl FoldChunks<'_> {
pub(crate) fn seek(&mut self, range: Range<FoldOffset>) {
- self.transform_cursor.seek(&range.start, Bias::Right, &());
+ self.transform_cursor.seek(&range.start, Bias::Right);
let inlay_start = {
let overshoot = range.start.0 - self.transform_cursor.start().0.0;
self.transform_cursor.start().1 + InlayOffset(overshoot)
};
- let transform_end = self.transform_cursor.end(&());
+ let transform_end = self.transform_cursor.end();
let inlay_end = if self
.transform_cursor
@@ -1376,10 +1369,10 @@ impl<'a> Iterator for FoldChunks<'a> {
self.inlay_chunk.take();
self.inlay_offset += InlayOffset(transform.summary.input.len);
- while self.inlay_offset >= self.transform_cursor.end(&()).1
+ while self.inlay_offset >= self.transform_cursor.end().1
&& self.transform_cursor.item().is_some()
{
- self.transform_cursor.next(&());
+ self.transform_cursor.next();
}
self.output_offset.0 += placeholder.text.len();
@@ -1396,7 +1389,7 @@ impl<'a> Iterator for FoldChunks<'a> {
&& self.inlay_chunks.offset() != self.inlay_offset
{
let transform_start = self.transform_cursor.start();
- let transform_end = self.transform_cursor.end(&());
+ let transform_end = self.transform_cursor.end();
let inlay_end = if self.max_output_offset < transform_end.0 {
let overshoot = self.max_output_offset.0 - transform_start.0.0;
transform_start.1 + InlayOffset(overshoot)
@@ -1417,14 +1410,14 @@ impl<'a> Iterator for FoldChunks<'a> {
if let Some((buffer_chunk_start, mut inlay_chunk)) = self.inlay_chunk.clone() {
let chunk = &mut inlay_chunk.chunk;
let buffer_chunk_end = buffer_chunk_start + InlayOffset(chunk.text.len());
- let transform_end = self.transform_cursor.end(&()).1;
+ let transform_end = self.transform_cursor.end().1;
let chunk_end = buffer_chunk_end.min(transform_end);
chunk.text = &chunk.text
[(self.inlay_offset - buffer_chunk_start).0..(chunk_end - buffer_chunk_start).0];
if chunk_end == transform_end {
- self.transform_cursor.next(&());
+ self.transform_cursor.next();
} else if chunk_end == buffer_chunk_end {
self.inlay_chunk.take();
}
@@ -1456,7 +1449,7 @@ impl FoldOffset {
let mut cursor = snapshot
.transforms
.cursor::<(FoldOffset, TransformSummary)>(&());
- cursor.seek(&self, Bias::Right, &());
+ cursor.seek(&self, Bias::Right);
let overshoot = if cursor.item().map_or(true, |t| t.is_fold()) {
Point::new(0, (self.0 - cursor.start().0.0) as u32)
} else {
@@ -1470,7 +1463,7 @@ impl FoldOffset {
#[cfg(test)]
pub fn to_inlay_offset(self, snapshot: &FoldSnapshot) -> InlayOffset {
let mut cursor = snapshot.transforms.cursor::<(FoldOffset, InlayOffset)>(&());
- cursor.seek(&self, Bias::Right, &());
+ cursor.seek(&self, Bias::Right);
let overshoot = self.0 - cursor.start().0.0;
InlayOffset(cursor.start().1.0 + overshoot)
}
@@ -263,7 +263,7 @@ pub struct InlayChunk<'a> {
impl InlayChunks<'_> {
pub fn seek(&mut self, new_range: Range<InlayOffset>) {
- self.transforms.seek(&new_range.start, Bias::Right, &());
+ self.transforms.seek(&new_range.start, Bias::Right);
let buffer_range = self.snapshot.to_buffer_offset(new_range.start)
..self.snapshot.to_buffer_offset(new_range.end);
@@ -296,12 +296,12 @@ impl<'a> Iterator for InlayChunks<'a> {
*chunk = self.buffer_chunks.next().unwrap();
}
- let desired_bytes = self.transforms.end(&()).0.0 - self.output_offset.0;
+ let desired_bytes = self.transforms.end().0.0 - self.output_offset.0;
// If we're already at the transform boundary, skip to the next transform
if desired_bytes == 0 {
self.inlay_chunks = None;
- self.transforms.next(&());
+ self.transforms.next();
return self.next();
}
@@ -397,7 +397,7 @@ impl<'a> Iterator for InlayChunks<'a> {
let inlay_chunks = self.inlay_chunks.get_or_insert_with(|| {
let start = offset_in_inlay;
- let end = cmp::min(self.max_output_offset, self.transforms.end(&()).0)
+ let end = cmp::min(self.max_output_offset, self.transforms.end().0)
- self.transforms.start().0;
inlay.text.chunks_in_range(start.0..end.0)
});
@@ -441,9 +441,9 @@ impl<'a> Iterator for InlayChunks<'a> {
}
};
- if self.output_offset >= self.transforms.end(&()).0 {
+ if self.output_offset >= self.transforms.end().0 {
self.inlay_chunks = None;
- self.transforms.next(&());
+ self.transforms.next();
}
Some(chunk)
@@ -453,7 +453,7 @@ impl<'a> Iterator for InlayChunks<'a> {
impl InlayBufferRows<'_> {
pub fn seek(&mut self, row: u32) {
let inlay_point = InlayPoint::new(row, 0);
- self.transforms.seek(&inlay_point, Bias::Left, &());
+ self.transforms.seek(&inlay_point, Bias::Left);
let mut buffer_point = self.transforms.start().1;
let buffer_row = MultiBufferRow(if row == 0 {
@@ -487,7 +487,7 @@ impl Iterator for InlayBufferRows<'_> {
self.inlay_row += 1;
self.transforms
- .seek_forward(&InlayPoint::new(self.inlay_row, 0), Bias::Left, &());
+ .seek_forward(&InlayPoint::new(self.inlay_row, 0), Bias::Left);
Some(buffer_row)
}
@@ -556,18 +556,18 @@ impl InlayMap {
let mut cursor = snapshot.transforms.cursor::<(usize, InlayOffset)>(&());
let mut buffer_edits_iter = buffer_edits.iter().peekable();
while let Some(buffer_edit) = buffer_edits_iter.next() {
- new_transforms.append(cursor.slice(&buffer_edit.old.start, Bias::Left, &()), &());
+ new_transforms.append(cursor.slice(&buffer_edit.old.start, Bias::Left), &());
if let Some(Transform::Isomorphic(transform)) = cursor.item() {
- if cursor.end(&()).0 == buffer_edit.old.start {
+ if cursor.end().0 == buffer_edit.old.start {
push_isomorphic(&mut new_transforms, *transform);
- cursor.next(&());
+ cursor.next();
}
}
// Remove all the inlays and transforms contained by the edit.
let old_start =
cursor.start().1 + InlayOffset(buffer_edit.old.start - cursor.start().0);
- cursor.seek(&buffer_edit.old.end, Bias::Right, &());
+ cursor.seek(&buffer_edit.old.end, Bias::Right);
let old_end =
cursor.start().1 + InlayOffset(buffer_edit.old.end - cursor.start().0);
@@ -625,20 +625,20 @@ impl InlayMap {
// we can push its remainder.
if buffer_edits_iter
.peek()
- .map_or(true, |edit| edit.old.start >= cursor.end(&()).0)
+ .map_or(true, |edit| edit.old.start >= cursor.end().0)
{
let transform_start = new_transforms.summary().input.len;
let transform_end =
- buffer_edit.new.end + (cursor.end(&()).0 - buffer_edit.old.end);
+ buffer_edit.new.end + (cursor.end().0 - buffer_edit.old.end);
push_isomorphic(
&mut new_transforms,
buffer_snapshot.text_summary_for_range(transform_start..transform_end),
);
- cursor.next(&());
+ cursor.next();
}
}
- new_transforms.append(cursor.suffix(&()), &());
+ new_transforms.append(cursor.suffix(), &());
if new_transforms.is_empty() {
new_transforms.push(Transform::Isomorphic(Default::default()), &());
}
@@ -773,7 +773,7 @@ impl InlaySnapshot {
let mut cursor = self
.transforms
.cursor::<(InlayOffset, (InlayPoint, usize))>(&());
- cursor.seek(&offset, Bias::Right, &());
+ cursor.seek(&offset, Bias::Right);
let overshoot = offset.0 - cursor.start().0.0;
match cursor.item() {
Some(Transform::Isomorphic(_)) => {
@@ -803,7 +803,7 @@ impl InlaySnapshot {
let mut cursor = self
.transforms
.cursor::<(InlayPoint, (InlayOffset, Point))>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
let overshoot = point.0 - cursor.start().0.0;
match cursor.item() {
Some(Transform::Isomorphic(_)) => {
@@ -822,7 +822,7 @@ impl InlaySnapshot {
}
pub fn to_buffer_point(&self, point: InlayPoint) -> Point {
let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
match cursor.item() {
Some(Transform::Isomorphic(_)) => {
let overshoot = point.0 - cursor.start().0.0;
@@ -834,7 +834,7 @@ impl InlaySnapshot {
}
pub fn to_buffer_offset(&self, offset: InlayOffset) -> usize {
let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&());
- cursor.seek(&offset, Bias::Right, &());
+ cursor.seek(&offset, Bias::Right);
match cursor.item() {
Some(Transform::Isomorphic(_)) => {
let overshoot = offset - cursor.start().0;
@@ -847,19 +847,19 @@ impl InlaySnapshot {
pub fn to_inlay_offset(&self, offset: usize) -> InlayOffset {
let mut cursor = self.transforms.cursor::<(usize, InlayOffset)>(&());
- cursor.seek(&offset, Bias::Left, &());
+ cursor.seek(&offset, Bias::Left);
loop {
match cursor.item() {
Some(Transform::Isomorphic(_)) => {
- if offset == cursor.end(&()).0 {
+ if offset == cursor.end().0 {
while let Some(Transform::Inlay(inlay)) = cursor.next_item() {
if inlay.position.bias() == Bias::Right {
break;
} else {
- cursor.next(&());
+ cursor.next();
}
}
- return cursor.end(&()).1;
+ return cursor.end().1;
} else {
let overshoot = offset - cursor.start().0;
return InlayOffset(cursor.start().1.0 + overshoot);
@@ -867,7 +867,7 @@ impl InlaySnapshot {
}
Some(Transform::Inlay(inlay)) => {
if inlay.position.bias() == Bias::Left {
- cursor.next(&());
+ cursor.next();
} else {
return cursor.start().1;
}
@@ -880,19 +880,19 @@ impl InlaySnapshot {
}
pub fn to_inlay_point(&self, point: Point) -> InlayPoint {
let mut cursor = self.transforms.cursor::<(Point, InlayPoint)>(&());
- cursor.seek(&point, Bias::Left, &());
+ cursor.seek(&point, Bias::Left);
loop {
match cursor.item() {
Some(Transform::Isomorphic(_)) => {
- if point == cursor.end(&()).0 {
+ if point == cursor.end().0 {
while let Some(Transform::Inlay(inlay)) = cursor.next_item() {
if inlay.position.bias() == Bias::Right {
break;
} else {
- cursor.next(&());
+ cursor.next();
}
}
- return cursor.end(&()).1;
+ return cursor.end().1;
} else {
let overshoot = point - cursor.start().0;
return InlayPoint(cursor.start().1.0 + overshoot);
@@ -900,7 +900,7 @@ impl InlaySnapshot {
}
Some(Transform::Inlay(inlay)) => {
if inlay.position.bias() == Bias::Left {
- cursor.next(&());
+ cursor.next();
} else {
return cursor.start().1;
}
@@ -914,7 +914,7 @@ impl InlaySnapshot {
pub fn clip_point(&self, mut point: InlayPoint, mut bias: Bias) -> InlayPoint {
let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&());
- cursor.seek(&point, Bias::Left, &());
+ cursor.seek(&point, Bias::Left);
loop {
match cursor.item() {
Some(Transform::Isomorphic(transform)) => {
@@ -923,7 +923,7 @@ impl InlaySnapshot {
if inlay.position.bias() == Bias::Left {
return point;
} else if bias == Bias::Left {
- cursor.prev(&());
+ cursor.prev();
} else if transform.first_line_chars == 0 {
point.0 += Point::new(1, 0);
} else {
@@ -932,12 +932,12 @@ impl InlaySnapshot {
} else {
return point;
}
- } else if cursor.end(&()).0 == point {
+ } else if cursor.end().0 == point {
if let Some(Transform::Inlay(inlay)) = cursor.next_item() {
if inlay.position.bias() == Bias::Right {
return point;
} else if bias == Bias::Right {
- cursor.next(&());
+ cursor.next();
} else if point.0.column == 0 {
point.0.row -= 1;
point.0.column = self.line_len(point.0.row);
@@ -970,7 +970,7 @@ impl InlaySnapshot {
}
_ => return point,
}
- } else if point == cursor.end(&()).0 && inlay.position.bias() == Bias::Left {
+ } else if point == cursor.end().0 && inlay.position.bias() == Bias::Left {
match cursor.next_item() {
Some(Transform::Inlay(inlay)) => {
if inlay.position.bias() == Bias::Right {
@@ -983,9 +983,9 @@ impl InlaySnapshot {
if bias == Bias::Left {
point = cursor.start().0;
- cursor.prev(&());
+ cursor.prev();
} else {
- cursor.next(&());
+ cursor.next();
point = cursor.start().0;
}
}
@@ -993,9 +993,9 @@ impl InlaySnapshot {
bias = bias.invert();
if bias == Bias::Left {
point = cursor.start().0;
- cursor.prev(&());
+ cursor.prev();
} else {
- cursor.next(&());
+ cursor.next();
point = cursor.start().0;
}
}
@@ -1011,7 +1011,7 @@ impl InlaySnapshot {
let mut summary = TextSummary::default();
let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&());
- cursor.seek(&range.start, Bias::Right, &());
+ cursor.seek(&range.start, Bias::Right);
let overshoot = range.start.0 - cursor.start().0.0;
match cursor.item() {
@@ -1019,22 +1019,22 @@ impl InlaySnapshot {
let buffer_start = cursor.start().1;
let suffix_start = buffer_start + overshoot;
let suffix_end =
- buffer_start + (cmp::min(cursor.end(&()).0, range.end).0 - cursor.start().0.0);
+ buffer_start + (cmp::min(cursor.end().0, range.end).0 - cursor.start().0.0);
summary = self.buffer.text_summary_for_range(suffix_start..suffix_end);
- cursor.next(&());
+ cursor.next();
}
Some(Transform::Inlay(inlay)) => {
let suffix_start = overshoot;
- let suffix_end = cmp::min(cursor.end(&()).0, range.end).0 - cursor.start().0.0;
+ let suffix_end = cmp::min(cursor.end().0, range.end).0 - cursor.start().0.0;
summary = inlay.text.cursor(suffix_start).summary(suffix_end);
- cursor.next(&());
+ cursor.next();
}
None => {}
}
if range.end > cursor.start().0 {
summary += cursor
- .summary::<_, TransformSummary>(&range.end, Bias::Right, &())
+ .summary::<_, TransformSummary>(&range.end, Bias::Right)
.output;
let overshoot = range.end.0 - cursor.start().0.0;
@@ -1060,7 +1060,7 @@ impl InlaySnapshot {
pub fn row_infos(&self, row: u32) -> InlayBufferRows<'_> {
let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&());
let inlay_point = InlayPoint::new(row, 0);
- cursor.seek(&inlay_point, Bias::Left, &());
+ cursor.seek(&inlay_point, Bias::Left);
let max_buffer_row = self.buffer.max_row();
let mut buffer_point = cursor.start().1;
@@ -1101,7 +1101,7 @@ impl InlaySnapshot {
highlights: Highlights<'a>,
) -> InlayChunks<'a> {
let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&());
- cursor.seek(&range.start, Bias::Right, &());
+ cursor.seek(&range.start, Bias::Right);
let buffer_range = self.to_buffer_offset(range.start)..self.to_buffer_offset(range.end);
let buffer_chunks = CustomHighlightsChunks::new(
@@ -72,7 +72,7 @@ pub struct WrapRows<'a> {
impl WrapRows<'_> {
pub(crate) fn seek(&mut self, start_row: u32) {
self.transforms
- .seek(&WrapPoint::new(start_row, 0), Bias::Left, &());
+ .seek(&WrapPoint::new(start_row, 0), Bias::Left);
let mut input_row = self.transforms.start().1.row();
if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
input_row += start_row - self.transforms.start().0.row();
@@ -340,7 +340,7 @@ impl WrapSnapshot {
let mut tab_edits_iter = tab_edits.iter().peekable();
new_transforms =
- old_cursor.slice(&tab_edits_iter.peek().unwrap().old.start, Bias::Right, &());
+ old_cursor.slice(&tab_edits_iter.peek().unwrap().old.start, Bias::Right);
while let Some(edit) = tab_edits_iter.next() {
if edit.new.start > TabPoint::from(new_transforms.summary().input.lines) {
@@ -356,31 +356,29 @@ impl WrapSnapshot {
));
}
- old_cursor.seek_forward(&edit.old.end, Bias::Right, &());
+ old_cursor.seek_forward(&edit.old.end, Bias::Right);
if let Some(next_edit) = tab_edits_iter.peek() {
- if next_edit.old.start > old_cursor.end(&()) {
- if old_cursor.end(&()) > edit.old.end {
+ if next_edit.old.start > old_cursor.end() {
+ if old_cursor.end() > edit.old.end {
let summary = self
.tab_snapshot
- .text_summary_for_range(edit.old.end..old_cursor.end(&()));
+ .text_summary_for_range(edit.old.end..old_cursor.end());
new_transforms.push_or_extend(Transform::isomorphic(summary));
}
- old_cursor.next(&());
- new_transforms.append(
- old_cursor.slice(&next_edit.old.start, Bias::Right, &()),
- &(),
- );
+ old_cursor.next();
+ new_transforms
+ .append(old_cursor.slice(&next_edit.old.start, Bias::Right), &());
}
} else {
- if old_cursor.end(&()) > edit.old.end {
+ if old_cursor.end() > edit.old.end {
let summary = self
.tab_snapshot
- .text_summary_for_range(edit.old.end..old_cursor.end(&()));
+ .text_summary_for_range(edit.old.end..old_cursor.end());
new_transforms.push_or_extend(Transform::isomorphic(summary));
}
- old_cursor.next(&());
- new_transforms.append(old_cursor.suffix(&()), &());
+ old_cursor.next();
+ new_transforms.append(old_cursor.suffix(), &());
}
}
}
@@ -441,7 +439,6 @@ impl WrapSnapshot {
new_transforms = old_cursor.slice(
&TabPoint::new(row_edits.peek().unwrap().old_rows.start, 0),
Bias::Right,
- &(),
);
while let Some(edit) = row_edits.next() {
@@ -516,34 +513,31 @@ impl WrapSnapshot {
}
new_transforms.extend(edit_transforms, &());
- old_cursor.seek_forward(&TabPoint::new(edit.old_rows.end, 0), Bias::Right, &());
+ old_cursor.seek_forward(&TabPoint::new(edit.old_rows.end, 0), Bias::Right);
if let Some(next_edit) = row_edits.peek() {
- if next_edit.old_rows.start > old_cursor.end(&()).row() {
- if old_cursor.end(&()) > TabPoint::new(edit.old_rows.end, 0) {
+ if next_edit.old_rows.start > old_cursor.end().row() {
+ if old_cursor.end() > TabPoint::new(edit.old_rows.end, 0) {
let summary = self.tab_snapshot.text_summary_for_range(
- TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(&()),
+ TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(),
);
new_transforms.push_or_extend(Transform::isomorphic(summary));
}
- old_cursor.next(&());
+ old_cursor.next();
new_transforms.append(
- old_cursor.slice(
- &TabPoint::new(next_edit.old_rows.start, 0),
- Bias::Right,
- &(),
- ),
+ old_cursor
+ .slice(&TabPoint::new(next_edit.old_rows.start, 0), Bias::Right),
&(),
);
}
} else {
- if old_cursor.end(&()) > TabPoint::new(edit.old_rows.end, 0) {
+ if old_cursor.end() > TabPoint::new(edit.old_rows.end, 0) {
let summary = self.tab_snapshot.text_summary_for_range(
- TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(&()),
+ TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(),
);
new_transforms.push_or_extend(Transform::isomorphic(summary));
}
- old_cursor.next(&());
- new_transforms.append(old_cursor.suffix(&()), &());
+ old_cursor.next();
+ new_transforms.append(old_cursor.suffix(), &());
}
}
}
@@ -570,19 +564,19 @@ impl WrapSnapshot {
tab_edit.new.start.0.column = 0;
tab_edit.new.end.0 += Point::new(1, 0);
- old_cursor.seek(&tab_edit.old.start, Bias::Right, &());
+ old_cursor.seek(&tab_edit.old.start, Bias::Right);
let mut old_start = old_cursor.start().output.lines;
old_start += tab_edit.old.start.0 - old_cursor.start().input.lines;
- old_cursor.seek(&tab_edit.old.end, Bias::Right, &());
+ old_cursor.seek(&tab_edit.old.end, Bias::Right);
let mut old_end = old_cursor.start().output.lines;
old_end += tab_edit.old.end.0 - old_cursor.start().input.lines;
- new_cursor.seek(&tab_edit.new.start, Bias::Right, &());
+ new_cursor.seek(&tab_edit.new.start, Bias::Right);
let mut new_start = new_cursor.start().output.lines;
new_start += tab_edit.new.start.0 - new_cursor.start().input.lines;
- new_cursor.seek(&tab_edit.new.end, Bias::Right, &());
+ new_cursor.seek(&tab_edit.new.end, Bias::Right);
let mut new_end = new_cursor.start().output.lines;
new_end += tab_edit.new.end.0 - new_cursor.start().input.lines;
@@ -605,7 +599,7 @@ impl WrapSnapshot {
let output_start = WrapPoint::new(rows.start, 0);
let output_end = WrapPoint::new(rows.end, 0);
let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
- transforms.seek(&output_start, Bias::Right, &());
+ transforms.seek(&output_start, Bias::Right);
let mut input_start = TabPoint(transforms.start().1.0);
if transforms.item().map_or(false, |t| t.is_isomorphic()) {
input_start.0 += output_start.0 - transforms.start().0.0;
@@ -633,7 +627,7 @@ impl WrapSnapshot {
pub fn line_len(&self, row: u32) -> u32 {
let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
- cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Left, &());
+ cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Left);
if cursor
.item()
.map_or(false, |transform| transform.is_isomorphic())
@@ -658,10 +652,10 @@ impl WrapSnapshot {
let end = WrapPoint::new(rows.end, 0);
let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
- cursor.seek(&start, Bias::Right, &());
+ cursor.seek(&start, Bias::Right);
if let Some(transform) = cursor.item() {
let start_in_transform = start.0 - cursor.start().0.0;
- let end_in_transform = cmp::min(end, cursor.end(&()).0).0 - cursor.start().0.0;
+ let end_in_transform = cmp::min(end, cursor.end().0).0 - cursor.start().0.0;
if transform.is_isomorphic() {
let tab_start = TabPoint(cursor.start().1.0 + start_in_transform);
let tab_end = TabPoint(cursor.start().1.0 + end_in_transform);
@@ -678,12 +672,12 @@ impl WrapSnapshot {
};
}
- cursor.next(&());
+ cursor.next();
}
if rows.end > cursor.start().0.row() {
summary += &cursor
- .summary::<_, TransformSummary>(&WrapPoint::new(rows.end, 0), Bias::Right, &())
+ .summary::<_, TransformSummary>(&WrapPoint::new(rows.end, 0), Bias::Right)
.output;
if let Some(transform) = cursor.item() {
@@ -712,7 +706,7 @@ impl WrapSnapshot {
pub fn soft_wrap_indent(&self, row: u32) -> Option<u32> {
let mut cursor = self.transforms.cursor::<WrapPoint>(&());
- cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Right, &());
+ cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Right);
cursor.item().and_then(|transform| {
if transform.is_isomorphic() {
None
@@ -728,7 +722,7 @@ impl WrapSnapshot {
pub fn row_infos(&self, start_row: u32) -> WrapRows<'_> {
let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
- transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left, &());
+ transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left);
let mut input_row = transforms.start().1.row();
if transforms.item().map_or(false, |t| t.is_isomorphic()) {
input_row += start_row - transforms.start().0.row();
@@ -748,7 +742,7 @@ impl WrapSnapshot {
pub fn to_tab_point(&self, point: WrapPoint) -> TabPoint {
let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
let mut tab_point = cursor.start().1.0;
if cursor.item().map_or(false, |t| t.is_isomorphic()) {
tab_point += point.0 - cursor.start().0.0;
@@ -766,14 +760,14 @@ impl WrapSnapshot {
pub fn tab_point_to_wrap_point(&self, point: TabPoint) -> WrapPoint {
let mut cursor = self.transforms.cursor::<(TabPoint, WrapPoint)>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
WrapPoint(cursor.start().1.0 + (point.0 - cursor.start().0.0))
}
pub fn clip_point(&self, mut point: WrapPoint, bias: Bias) -> WrapPoint {
if bias == Bias::Left {
let mut cursor = self.transforms.cursor::<WrapPoint>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
if cursor.item().map_or(false, |t| !t.is_isomorphic()) {
point = *cursor.start();
*point.column_mut() -= 1;
@@ -791,16 +785,16 @@ impl WrapSnapshot {
*point.column_mut() = 0;
let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
if cursor.item().is_none() {
- cursor.prev(&());
+ cursor.prev();
}
while let Some(transform) = cursor.item() {
if transform.is_isomorphic() && cursor.start().1.column() == 0 {
- return cmp::min(cursor.end(&()).0.row(), point.row());
+ return cmp::min(cursor.end().0.row(), point.row());
} else {
- cursor.prev(&());
+ cursor.prev();
}
}
@@ -811,12 +805,12 @@ impl WrapSnapshot {
point.0 += Point::new(1, 0);
let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
while let Some(transform) = cursor.item() {
if transform.is_isomorphic() && cursor.start().1.column() == 0 {
return Some(cmp::max(cursor.start().0.row(), point.row()));
} else {
- cursor.next(&());
+ cursor.next();
}
}
@@ -889,7 +883,7 @@ impl WrapChunks<'_> {
pub(crate) fn seek(&mut self, rows: Range<u32>) {
let output_start = WrapPoint::new(rows.start, 0);
let output_end = WrapPoint::new(rows.end, 0);
- self.transforms.seek(&output_start, Bias::Right, &());
+ self.transforms.seek(&output_start, Bias::Right);
let mut input_start = TabPoint(self.transforms.start().1.0);
if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
input_start.0 += output_start.0 - self.transforms.start().0.0;
@@ -930,7 +924,7 @@ impl<'a> Iterator for WrapChunks<'a> {
}
self.output_position.0 += summary;
- self.transforms.next(&());
+ self.transforms.next();
return Some(Chunk {
text: &display_text[start_ix..end_ix],
..Default::default()
@@ -942,7 +936,7 @@ impl<'a> Iterator for WrapChunks<'a> {
}
let mut input_len = 0;
- let transform_end = self.transforms.end(&()).0;
+ let transform_end = self.transforms.end().0;
for c in self.input_chunk.text.chars() {
let char_len = c.len_utf8();
input_len += char_len;
@@ -954,7 +948,7 @@ impl<'a> Iterator for WrapChunks<'a> {
}
if self.output_position >= transform_end {
- self.transforms.next(&());
+ self.transforms.next();
break;
}
}
@@ -982,7 +976,7 @@ impl Iterator for WrapRows<'_> {
self.output_row += 1;
self.transforms
- .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left, &());
+ .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left);
if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
self.input_buffer_row = self.input_buffer_rows.next().unwrap();
self.soft_wrapped = false;
@@ -296,7 +296,7 @@ impl GitBlame {
let row = info
.buffer_row
.filter(|_| info.buffer_id == Some(buffer_id))?;
- cursor.seek_forward(&row, Bias::Right, &());
+ cursor.seek_forward(&row, Bias::Right);
cursor.item()?.blame.clone()
})
}
@@ -389,7 +389,7 @@ impl GitBlame {
}
}
- new_entries.append(cursor.slice(&edit.old.start, Bias::Right, &()), &());
+ new_entries.append(cursor.slice(&edit.old.start, Bias::Right), &());
if edit.new.start > new_entries.summary().rows {
new_entries.push(
@@ -401,7 +401,7 @@ impl GitBlame {
);
}
- cursor.seek(&edit.old.end, Bias::Right, &());
+ cursor.seek(&edit.old.end, Bias::Right);
if !edit.new.is_empty() {
new_entries.push(
GitBlameEntry {
@@ -412,7 +412,7 @@ impl GitBlame {
);
}
- let old_end = cursor.end(&());
+ let old_end = cursor.end();
if row_edits
.peek()
.map_or(true, |next_edit| next_edit.old.start >= old_end)
@@ -421,18 +421,18 @@ impl GitBlame {
if old_end > edit.old.end {
new_entries.push(
GitBlameEntry {
- rows: cursor.end(&()) - edit.old.end,
+ rows: cursor.end() - edit.old.end,
blame: entry.blame.clone(),
},
&(),
);
}
- cursor.next(&());
+ cursor.next();
}
}
}
- new_entries.append(cursor.suffix(&()), &());
+ new_entries.append(cursor.suffix(), &());
drop(cursor);
self.buffer_snapshot = new_snapshot;
@@ -249,8 +249,8 @@ impl ListState {
let state = &mut *self.0.borrow_mut();
let mut old_items = state.items.cursor::<Count>(&());
- let mut new_items = old_items.slice(&Count(old_range.start), Bias::Right, &());
- old_items.seek_forward(&Count(old_range.end), Bias::Right, &());
+ let mut new_items = old_items.slice(&Count(old_range.start), Bias::Right);
+ old_items.seek_forward(&Count(old_range.end), Bias::Right);
let mut spliced_count = 0;
new_items.extend(
@@ -260,7 +260,7 @@ impl ListState {
}),
&(),
);
- new_items.append(old_items.suffix(&()), &());
+ new_items.append(old_items.suffix(), &());
drop(old_items);
state.items = new_items;
@@ -300,14 +300,14 @@ impl ListState {
let current_offset = self.logical_scroll_top();
let state = &mut *self.0.borrow_mut();
let mut cursor = state.items.cursor::<ListItemSummary>(&());
- cursor.seek(&Count(current_offset.item_ix), Bias::Right, &());
+ cursor.seek(&Count(current_offset.item_ix), Bias::Right);
let start_pixel_offset = cursor.start().height + current_offset.offset_in_item;
let new_pixel_offset = (start_pixel_offset + distance).max(px(0.));
if new_pixel_offset > start_pixel_offset {
- cursor.seek_forward(&Height(new_pixel_offset), Bias::Right, &());
+ cursor.seek_forward(&Height(new_pixel_offset), Bias::Right);
} else {
- cursor.seek(&Height(new_pixel_offset), Bias::Right, &());
+ cursor.seek(&Height(new_pixel_offset), Bias::Right);
}
state.logical_scroll_top = Some(ListOffset {
@@ -343,11 +343,11 @@ impl ListState {
scroll_top.offset_in_item = px(0.);
} else {
let mut cursor = state.items.cursor::<ListItemSummary>(&());
- cursor.seek(&Count(ix + 1), Bias::Right, &());
+ cursor.seek(&Count(ix + 1), Bias::Right);
let bottom = cursor.start().height + padding.top;
let goal_top = px(0.).max(bottom - height + padding.bottom);
- cursor.seek(&Height(goal_top), Bias::Left, &());
+ cursor.seek(&Height(goal_top), Bias::Left);
let start_ix = cursor.start().count;
let start_item_top = cursor.start().height;
@@ -372,11 +372,11 @@ impl ListState {
}
let mut cursor = state.items.cursor::<(Count, Height)>(&());
- cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &());
+ cursor.seek(&Count(scroll_top.item_ix), Bias::Right);
let scroll_top = cursor.start().1.0 + scroll_top.offset_in_item;
- cursor.seek_forward(&Count(ix), Bias::Right, &());
+ cursor.seek_forward(&Count(ix), Bias::Right);
if let Some(&ListItem::Measured { size, .. }) = cursor.item() {
let &(Count(count), Height(top)) = cursor.start();
if count == ix {
@@ -431,7 +431,7 @@ impl ListState {
let mut cursor = state.items.cursor::<ListItemSummary>(&());
let summary: ListItemSummary =
- cursor.summary(&Count(logical_scroll_top.item_ix), Bias::Right, &());
+ cursor.summary(&Count(logical_scroll_top.item_ix), Bias::Right);
let content_height = state.items.summary().height;
let drag_offset =
// if dragging the scrollbar, we want to offset the point if the height changed
@@ -450,9 +450,9 @@ impl ListState {
impl StateInner {
fn visible_range(&self, height: Pixels, scroll_top: &ListOffset) -> Range<usize> {
let mut cursor = self.items.cursor::<ListItemSummary>(&());
- cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &());
+ cursor.seek(&Count(scroll_top.item_ix), Bias::Right);
let start_y = cursor.start().height + scroll_top.offset_in_item;
- cursor.seek_forward(&Height(start_y + height), Bias::Left, &());
+ cursor.seek_forward(&Height(start_y + height), Bias::Left);
scroll_top.item_ix..cursor.start().count + 1
}
@@ -482,7 +482,7 @@ impl StateInner {
self.logical_scroll_top = None;
} else {
let mut cursor = self.items.cursor::<ListItemSummary>(&());
- cursor.seek(&Height(new_scroll_top), Bias::Right, &());
+ cursor.seek(&Height(new_scroll_top), Bias::Right);
let item_ix = cursor.start().count;
let offset_in_item = new_scroll_top - cursor.start().height;
self.logical_scroll_top = Some(ListOffset {
@@ -523,7 +523,7 @@ impl StateInner {
fn scroll_top(&self, logical_scroll_top: &ListOffset) -> Pixels {
let mut cursor = self.items.cursor::<ListItemSummary>(&());
- cursor.seek(&Count(logical_scroll_top.item_ix), Bias::Right, &());
+ cursor.seek(&Count(logical_scroll_top.item_ix), Bias::Right);
cursor.start().height + logical_scroll_top.offset_in_item
}
@@ -553,7 +553,7 @@ impl StateInner {
let mut cursor = old_items.cursor::<Count>(&());
// Render items after the scroll top, including those in the trailing overdraw
- cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &());
+ cursor.seek(&Count(scroll_top.item_ix), Bias::Right);
for (ix, item) in cursor.by_ref().enumerate() {
let visible_height = rendered_height - scroll_top.offset_in_item;
if visible_height >= available_height + self.overdraw {
@@ -592,13 +592,13 @@ impl StateInner {
rendered_height += padding.bottom;
// Prepare to start walking upward from the item at the scroll top.
- cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &());
+ cursor.seek(&Count(scroll_top.item_ix), Bias::Right);
// If the rendered items do not fill the visible region, then adjust
// the scroll top upward.
if rendered_height - scroll_top.offset_in_item < available_height {
while rendered_height < available_height {
- cursor.prev(&());
+ cursor.prev();
if let Some(item) = cursor.item() {
let item_index = cursor.start().0;
let mut element = (self.render_item)(item_index, window, cx);
@@ -645,7 +645,7 @@ impl StateInner {
// Measure items in the leading overdraw
let mut leading_overdraw = scroll_top.offset_in_item;
while leading_overdraw < self.overdraw {
- cursor.prev(&());
+ cursor.prev();
if let Some(item) = cursor.item() {
let size = if let ListItem::Measured { size, .. } = item {
*size
@@ -666,10 +666,10 @@ impl StateInner {
let measured_range = cursor.start().0..(cursor.start().0 + measured_items.len());
let mut cursor = old_items.cursor::<Count>(&());
- let mut new_items = cursor.slice(&Count(measured_range.start), Bias::Right, &());
+ let mut new_items = cursor.slice(&Count(measured_range.start), Bias::Right);
new_items.extend(measured_items, &());
- cursor.seek(&Count(measured_range.end), Bias::Right, &());
- new_items.append(cursor.suffix(&()), &());
+ cursor.seek(&Count(measured_range.end), Bias::Right);
+ new_items.append(cursor.suffix(), &());
self.items = new_items;
// If none of the visible items are focused, check if an off-screen item is focused
@@ -679,7 +679,7 @@ impl StateInner {
let mut cursor = self
.items
.filter::<_, Count>(&(), |summary| summary.has_focus_handles);
- cursor.next(&());
+ cursor.next();
while let Some(item) = cursor.item() {
if item.contains_focused(window, cx) {
let item_index = cursor.start().0;
@@ -692,7 +692,7 @@ impl StateInner {
});
break;
}
- cursor.next(&());
+ cursor.next();
}
}
@@ -741,7 +741,7 @@ impl StateInner {
});
} else if autoscroll_bounds.bottom() > bounds.bottom() {
let mut cursor = self.items.cursor::<Count>(&());
- cursor.seek(&Count(item.index), Bias::Right, &());
+ cursor.seek(&Count(item.index), Bias::Right);
let mut height = bounds.size.height - padding.top - padding.bottom;
// Account for the height of the element down until the autoscroll bottom.
@@ -749,7 +749,7 @@ impl StateInner {
// Keep decreasing the scroll top until we fill all the available space.
while height > Pixels::ZERO {
- cursor.prev(&());
+ cursor.prev();
let Some(item) = cursor.item() else { break };
let size = item.size().unwrap_or_else(|| {
@@ -806,7 +806,7 @@ impl StateInner {
self.logical_scroll_top = None;
} else {
let mut cursor = self.items.cursor::<ListItemSummary>(&());
- cursor.seek(&Height(new_scroll_top), Bias::Right, &());
+ cursor.seek(&Height(new_scroll_top), Bias::Right);
let item_ix = cursor.start().count;
let offset_in_item = new_scroll_top - cursor.start().height;
@@ -158,17 +158,17 @@ impl DiagnosticSet {
});
if reversed {
- cursor.prev(buffer);
+ cursor.prev();
} else {
- cursor.next(buffer);
+ cursor.next();
}
iter::from_fn({
move || {
if let Some(diagnostic) = cursor.item() {
if reversed {
- cursor.prev(buffer);
+ cursor.prev();
} else {
- cursor.next(buffer);
+ cursor.next();
}
Some(diagnostic.resolve(buffer))
} else {
@@ -297,10 +297,10 @@ impl SyntaxSnapshot {
let mut first_edit_ix_for_depth = 0;
let mut prev_depth = 0;
let mut cursor = self.layers.cursor::<SyntaxLayerSummary>(text);
- cursor.next(text);
+ cursor.next();
'outer: loop {
- let depth = cursor.end(text).max_depth;
+ let depth = cursor.end().max_depth;
if depth > prev_depth {
first_edit_ix_for_depth = 0;
prev_depth = depth;
@@ -313,7 +313,7 @@ impl SyntaxSnapshot {
position: edit_range.start,
};
if target.cmp(cursor.start(), text).is_gt() {
- let slice = cursor.slice(&target, Bias::Left, text);
+ let slice = cursor.slice(&target, Bias::Left);
layers.append(slice, text);
}
}
@@ -327,7 +327,6 @@ impl SyntaxSnapshot {
language: None,
},
Bias::Left,
- text,
);
layers.append(slice, text);
continue;
@@ -394,10 +393,10 @@ impl SyntaxSnapshot {
}
layers.push(layer, text);
- cursor.next(text);
+ cursor.next();
}
- layers.append(cursor.suffix(text), text);
+ layers.append(cursor.suffix(), text);
drop(cursor);
self.layers = layers;
}
@@ -420,7 +419,7 @@ impl SyntaxSnapshot {
let mut cursor = self
.layers
.filter::<_, ()>(text, |summary| summary.contains_unknown_injections);
- cursor.next(text);
+ cursor.next();
while let Some(layer) = cursor.item() {
let SyntaxLayerContent::Pending { language_name } = &layer.content else {
unreachable!()
@@ -436,7 +435,7 @@ impl SyntaxSnapshot {
resolved_injection_ranges.push(range);
}
- cursor.next(text);
+ cursor.next();
}
drop(cursor);
@@ -469,7 +468,7 @@ impl SyntaxSnapshot {
let max_depth = self.layers.summary().max_depth;
let mut cursor = self.layers.cursor::<SyntaxLayerSummary>(text);
- cursor.next(text);
+ cursor.next();
let mut layers = SumTree::new(text);
let mut changed_regions = ChangeRegionSet::default();
@@ -514,7 +513,7 @@ impl SyntaxSnapshot {
};
let mut done = cursor.item().is_none();
- while !done && position.cmp(&cursor.end(text), text).is_gt() {
+ while !done && position.cmp(&cursor.end(), text).is_gt() {
done = true;
let bounded_position = SyntaxLayerPositionBeforeChange {
@@ -522,16 +521,16 @@ impl SyntaxSnapshot {
change: changed_regions.start_position(),
};
if bounded_position.cmp(cursor.start(), text).is_gt() {
- let slice = cursor.slice(&bounded_position, Bias::Left, text);
+ let slice = cursor.slice(&bounded_position, Bias::Left);
if !slice.is_empty() {
layers.append(slice, text);
- if changed_regions.prune(cursor.end(text), text) {
+ if changed_regions.prune(cursor.end(), text) {
done = false;
}
}
}
- while position.cmp(&cursor.end(text), text).is_gt() {
+ while position.cmp(&cursor.end(), text).is_gt() {
let Some(layer) = cursor.item() else { break };
if changed_regions.intersects(layer, text) {
@@ -555,8 +554,8 @@ impl SyntaxSnapshot {
layers.push(layer.clone(), text);
}
- cursor.next(text);
- if changed_regions.prune(cursor.end(text), text) {
+ cursor.next();
+ if changed_regions.prune(cursor.end(), text) {
done = false;
}
}
@@ -572,7 +571,7 @@ impl SyntaxSnapshot {
if layer.range.to_offset(text) == (step_start_byte..step_end_byte)
&& layer.content.language_id() == step.language.id()
{
- cursor.next(text);
+ cursor.next();
} else {
old_layer = None;
}
@@ -918,7 +917,7 @@ impl SyntaxSnapshot {
}
});
- cursor.next(buffer);
+ cursor.next();
iter::from_fn(move || {
while let Some(layer) = cursor.item() {
let mut info = None;
@@ -940,7 +939,7 @@ impl SyntaxSnapshot {
});
}
}
- cursor.next(buffer);
+ cursor.next();
if info.is_some() {
return info;
}
@@ -1211,7 +1211,7 @@ impl MultiBuffer {
let buffer = buffer_state.buffer.read(cx);
for range in buffer.edited_ranges_for_transaction_id::<D>(*buffer_transaction) {
for excerpt_id in &buffer_state.excerpts {
- cursor.seek(excerpt_id, Bias::Left, &());
+ cursor.seek(excerpt_id, Bias::Left);
if let Some(excerpt) = cursor.item() {
if excerpt.locator == *excerpt_id {
let excerpt_buffer_start =
@@ -1322,7 +1322,7 @@ impl MultiBuffer {
let start_locator = snapshot.excerpt_locator_for_id(selection.start.excerpt_id);
let end_locator = snapshot.excerpt_locator_for_id(selection.end.excerpt_id);
- cursor.seek(&Some(start_locator), Bias::Left, &());
+ cursor.seek(&Some(start_locator), Bias::Left);
while let Some(excerpt) = cursor.item() {
if excerpt.locator > *end_locator {
break;
@@ -1347,7 +1347,7 @@ impl MultiBuffer {
goal: selection.goal,
});
- cursor.next(&());
+ cursor.next();
}
}
@@ -1769,13 +1769,13 @@ impl MultiBuffer {
let mut next_excerpt_id = move || ExcerptId(post_inc(&mut next_excerpt_id));
let mut excerpts_cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
- excerpts_cursor.next(&());
+ excerpts_cursor.next();
loop {
let new = new_iter.peek();
let existing = if let Some(existing_id) = existing_iter.peek() {
let locator = snapshot.excerpt_locator_for_id(*existing_id);
- excerpts_cursor.seek_forward(&Some(locator), Bias::Left, &());
+ excerpts_cursor.seek_forward(&Some(locator), Bias::Left);
if let Some(excerpt) = excerpts_cursor.item() {
if excerpt.buffer_id != buffer_snapshot.remote_id() {
to_remove.push(*existing_id);
@@ -1970,7 +1970,7 @@ impl MultiBuffer {
let mut prev_locator = snapshot.excerpt_locator_for_id(prev_excerpt_id).clone();
let mut new_excerpt_ids = mem::take(&mut snapshot.excerpt_ids);
let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
- let mut new_excerpts = cursor.slice(&prev_locator, Bias::Right, &());
+ let mut new_excerpts = cursor.slice(&prev_locator, Bias::Right);
prev_locator = cursor.start().unwrap_or(Locator::min_ref()).clone();
let edit_start = ExcerptOffset::new(new_excerpts.summary().text.len);
@@ -2019,7 +2019,7 @@ impl MultiBuffer {
let edit_end = ExcerptOffset::new(new_excerpts.summary().text.len);
- let suffix = cursor.suffix(&());
+ let suffix = cursor.suffix();
let changed_trailing_excerpt = suffix.is_empty();
new_excerpts.append(suffix, &());
drop(cursor);
@@ -2104,7 +2104,7 @@ impl MultiBuffer {
.into_iter()
.flatten()
{
- cursor.seek_forward(&Some(locator), Bias::Left, &());
+ cursor.seek_forward(&Some(locator), Bias::Left);
if let Some(excerpt) = cursor.item() {
if excerpt.locator == *locator {
excerpts.push((excerpt.id, excerpt.range.clone()));
@@ -2124,25 +2124,25 @@ impl MultiBuffer {
let mut diff_transforms = snapshot
.diff_transforms
.cursor::<(ExcerptDimension<Point>, OutputDimension<Point>)>(&());
- diff_transforms.next(&());
+ diff_transforms.next();
let locators = buffers
.get(&buffer_id)
.into_iter()
.flat_map(|state| &state.excerpts);
let mut result = Vec::new();
for locator in locators {
- excerpts.seek_forward(&Some(locator), Bias::Left, &());
+ excerpts.seek_forward(&Some(locator), Bias::Left);
if let Some(excerpt) = excerpts.item() {
if excerpt.locator == *locator {
let excerpt_start = excerpts.start().1.clone();
let excerpt_end =
ExcerptDimension(excerpt_start.0 + excerpt.text_summary.lines);
- diff_transforms.seek_forward(&excerpt_start, Bias::Left, &());
+ diff_transforms.seek_forward(&excerpt_start, Bias::Left);
let overshoot = excerpt_start.0 - diff_transforms.start().0.0;
let start = diff_transforms.start().1.0 + overshoot;
- diff_transforms.seek_forward(&excerpt_end, Bias::Right, &());
+ diff_transforms.seek_forward(&excerpt_end, Bias::Right);
let overshoot = excerpt_end.0 - diff_transforms.start().0.0;
let end = diff_transforms.start().1.0 + overshoot;
@@ -2290,7 +2290,7 @@ impl MultiBuffer {
self.paths_by_excerpt.remove(&excerpt_id);
// Seek to the next excerpt to remove, preserving any preceding excerpts.
let locator = snapshot.excerpt_locator_for_id(excerpt_id);
- new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
+ new_excerpts.append(cursor.slice(&Some(locator), Bias::Left), &());
if let Some(mut excerpt) = cursor.item() {
if excerpt.id != excerpt_id {
@@ -2311,7 +2311,7 @@ impl MultiBuffer {
removed_buffer_ids.push(excerpt.buffer_id);
}
}
- cursor.next(&());
+ cursor.next();
// Skip over any subsequent excerpts that are also removed.
if let Some(&next_excerpt_id) = excerpt_ids.peek() {
@@ -2344,7 +2344,7 @@ impl MultiBuffer {
});
}
}
- let suffix = cursor.suffix(&());
+ let suffix = cursor.suffix();
let changed_trailing_excerpt = suffix.is_empty();
new_excerpts.append(suffix, &());
drop(cursor);
@@ -2493,7 +2493,7 @@ impl MultiBuffer {
let mut cursor = snapshot
.excerpts
.cursor::<(Option<&Locator>, ExcerptOffset)>(&());
- cursor.seek_forward(&Some(locator), Bias::Left, &());
+ cursor.seek_forward(&Some(locator), Bias::Left);
if let Some(excerpt) = cursor.item() {
if excerpt.locator == *locator {
let excerpt_buffer_range = excerpt.range.context.to_offset(&excerpt.buffer);
@@ -2724,7 +2724,7 @@ impl MultiBuffer {
let snapshot = self.read(cx);
let mut cursor = snapshot.diff_transforms.cursor::<usize>(&());
let offset_range = range.to_offset(&snapshot);
- cursor.seek(&offset_range.start, Bias::Left, &());
+ cursor.seek(&offset_range.start, Bias::Left);
while let Some(item) = cursor.item() {
if *cursor.start() >= offset_range.end && *cursor.start() > offset_range.start {
break;
@@ -2732,7 +2732,7 @@ impl MultiBuffer {
if item.hunk_info().is_some() {
return true;
}
- cursor.next(&());
+ cursor.next();
}
false
}
@@ -2746,7 +2746,7 @@ impl MultiBuffer {
let end = snapshot.point_to_offset(Point::new(range.end.row + 1, 0));
let start = start.saturating_sub(1);
let end = snapshot.len().min(end + 1);
- cursor.seek(&start, Bias::Right, &());
+ cursor.seek(&start, Bias::Right);
while let Some(item) = cursor.item() {
if *cursor.start() >= end {
break;
@@ -2754,7 +2754,7 @@ impl MultiBuffer {
if item.hunk_info().is_some() {
return true;
}
- cursor.next(&());
+ cursor.next();
}
}
false
@@ -2848,7 +2848,7 @@ impl MultiBuffer {
.cursor::<(Option<&Locator>, ExcerptOffset)>(&());
let mut edits = Vec::<Edit<ExcerptOffset>>::new();
- let prefix = cursor.slice(&Some(locator), Bias::Left, &());
+ let prefix = cursor.slice(&Some(locator), Bias::Left);
new_excerpts.append(prefix, &());
let mut excerpt = cursor.item().unwrap().clone();
@@ -2883,9 +2883,9 @@ impl MultiBuffer {
new_excerpts.push(excerpt, &());
- cursor.next(&());
+ cursor.next();
- new_excerpts.append(cursor.suffix(&()), &());
+ new_excerpts.append(cursor.suffix(), &());
drop(cursor);
snapshot.excerpts = new_excerpts;
@@ -2925,7 +2925,7 @@ impl MultiBuffer {
let mut edits = Vec::<Edit<ExcerptOffset>>::new();
for locator in &locators {
- let prefix = cursor.slice(&Some(locator), Bias::Left, &());
+ let prefix = cursor.slice(&Some(locator), Bias::Left);
new_excerpts.append(prefix, &());
let mut excerpt = cursor.item().unwrap().clone();
@@ -2987,10 +2987,10 @@ impl MultiBuffer {
new_excerpts.push(excerpt, &());
- cursor.next(&());
+ cursor.next();
}
- new_excerpts.append(cursor.suffix(&()), &());
+ new_excerpts.append(cursor.suffix(), &());
drop(cursor);
snapshot.excerpts = new_excerpts;
@@ -3070,7 +3070,7 @@ impl MultiBuffer {
.cursor::<(Option<&Locator>, ExcerptOffset)>(&());
for (locator, buffer, buffer_edited) in excerpts_to_edit {
- new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
+ new_excerpts.append(cursor.slice(&Some(locator), Bias::Left), &());
let old_excerpt = cursor.item().unwrap();
let buffer = buffer.read(cx);
let buffer_id = buffer.remote_id();
@@ -3112,9 +3112,9 @@ impl MultiBuffer {
}
new_excerpts.push(new_excerpt, &());
- cursor.next(&());
+ cursor.next();
}
- new_excerpts.append(cursor.suffix(&()), &());
+ new_excerpts.append(cursor.suffix(), &());
drop(cursor);
snapshot.excerpts = new_excerpts;
@@ -3145,23 +3145,22 @@ impl MultiBuffer {
let mut excerpt_edits = excerpt_edits.into_iter().peekable();
while let Some(edit) = excerpt_edits.next() {
- excerpts.seek_forward(&edit.new.start, Bias::Right, &());
+ excerpts.seek_forward(&edit.new.start, Bias::Right);
if excerpts.item().is_none() && *excerpts.start() == edit.new.start {
- excerpts.prev(&());
+ excerpts.prev();
}
// Keep any transforms that are before the edit.
if at_transform_boundary {
at_transform_boundary = false;
- let transforms_before_edit =
- old_diff_transforms.slice(&edit.old.start, Bias::Left, &());
+ let transforms_before_edit = old_diff_transforms.slice(&edit.old.start, Bias::Left);
self.append_diff_transforms(&mut new_diff_transforms, transforms_before_edit);
if let Some(transform) = old_diff_transforms.item() {
- if old_diff_transforms.end(&()).0 == edit.old.start
+ if old_diff_transforms.end().0 == edit.old.start
&& old_diff_transforms.start().0 < edit.old.start
{
self.push_diff_transform(&mut new_diff_transforms, transform.clone());
- old_diff_transforms.next(&());
+ old_diff_transforms.next();
}
}
}
@@ -3203,7 +3202,7 @@ impl MultiBuffer {
// then recreate the content up to the end of this transform, to prepare
// for reusing additional slices of the old transforms.
if excerpt_edits.peek().map_or(true, |next_edit| {
- next_edit.old.start >= old_diff_transforms.end(&()).0
+ next_edit.old.start >= old_diff_transforms.end().0
}) {
let keep_next_old_transform = (old_diff_transforms.start().0 >= edit.old.end)
&& match old_diff_transforms.item() {
@@ -3218,8 +3217,8 @@ impl MultiBuffer {
let mut excerpt_offset = edit.new.end;
if !keep_next_old_transform {
- excerpt_offset += old_diff_transforms.end(&()).0 - edit.old.end;
- old_diff_transforms.next(&());
+ excerpt_offset += old_diff_transforms.end().0 - edit.old.end;
+ old_diff_transforms.next();
}
old_expanded_hunks.clear();
@@ -3234,7 +3233,7 @@ impl MultiBuffer {
}
// Keep any transforms that are after the last edit.
- self.append_diff_transforms(&mut new_diff_transforms, old_diff_transforms.suffix(&()));
+ self.append_diff_transforms(&mut new_diff_transforms, old_diff_transforms.suffix());
// Ensure there's always at least one buffer content transform.
if new_diff_transforms.is_empty() {
@@ -3283,10 +3282,10 @@ impl MultiBuffer {
);
old_expanded_hunks.insert(hunk_info);
}
- if old_diff_transforms.end(&()).0 > edit.old.end {
+ if old_diff_transforms.end().0 > edit.old.end {
break;
}
- old_diff_transforms.next(&());
+ old_diff_transforms.next();
}
// Avoid querying diff hunks if there's no possibility of hunks being expanded.
@@ -3413,8 +3412,8 @@ impl MultiBuffer {
}
}
- if excerpts.end(&()) <= edit.new.end {
- excerpts.next(&());
+ if excerpts.end() <= edit.new.end {
+ excerpts.next();
} else {
break;
}
@@ -3439,9 +3438,9 @@ impl MultiBuffer {
*summary,
) {
let mut cursor = subtree.cursor::<()>(&());
- cursor.next(&());
- cursor.next(&());
- new_transforms.append(cursor.suffix(&()), &());
+ cursor.next();
+ cursor.next();
+ new_transforms.append(cursor.suffix(), &());
return;
}
}
@@ -4715,14 +4714,14 @@ impl MultiBufferSnapshot {
{
let range = range.start.to_offset(self)..range.end.to_offset(self);
let mut cursor = self.diff_transforms.cursor::<(usize, ExcerptOffset)>(&());
- cursor.seek(&range.start, Bias::Right, &());
+ cursor.seek(&range.start, Bias::Right);
let Some(first_transform) = cursor.item() else {
return D::from_text_summary(&TextSummary::default());
};
let diff_transform_start = cursor.start().0;
- let diff_transform_end = cursor.end(&()).0;
+ let diff_transform_end = cursor.end().0;
let diff_start = range.start;
let start_overshoot = diff_start - diff_transform_start;
let end_overshoot = std::cmp::min(range.end, diff_transform_end) - diff_transform_start;
@@ -4765,12 +4764,10 @@ impl MultiBufferSnapshot {
return result;
}
- cursor.next(&());
- result.add_assign(&D::from_text_summary(&cursor.summary(
- &range.end,
- Bias::Right,
- &(),
- )));
+ cursor.next();
+ result.add_assign(&D::from_text_summary(
+ &cursor.summary(&range.end, Bias::Right),
+ ));
let Some(last_transform) = cursor.item() else {
return result;
@@ -4813,9 +4810,9 @@ impl MultiBufferSnapshot {
// let mut range = range.start..range.end;
let mut summary = D::zero(&());
let mut cursor = self.excerpts.cursor::<ExcerptOffset>(&());
- cursor.seek(&range.start, Bias::Right, &());
+ cursor.seek(&range.start, Bias::Right);
if let Some(excerpt) = cursor.item() {
- let mut end_before_newline = cursor.end(&());
+ let mut end_before_newline = cursor.end();
if excerpt.has_trailing_newline {
end_before_newline -= ExcerptOffset::new(1);
}
@@ -4834,13 +4831,13 @@ impl MultiBufferSnapshot {
summary.add_assign(&D::from_text_summary(&TextSummary::from("\n")));
}
- cursor.next(&());
+ cursor.next();
}
if range.end > *cursor.start() {
summary.add_assign(
&cursor
- .summary::<_, ExcerptDimension<D>>(&range.end, Bias::Right, &())
+ .summary::<_, ExcerptDimension<D>>(&range.end, Bias::Right)
.0,
);
if let Some(excerpt) = cursor.item() {
@@ -4876,11 +4873,11 @@ impl MultiBufferSnapshot {
D: TextDimension + Ord + Sub<D, Output = D>,
{
loop {
- let transform_end_position = diff_transforms.end(&()).0.0;
+ let transform_end_position = diff_transforms.end().0.0;
let at_transform_end =
excerpt_position == transform_end_position && diff_transforms.item().is_some();
if at_transform_end && anchor.text_anchor.bias == Bias::Right {
- diff_transforms.next(&());
+ diff_transforms.next();
continue;
}
@@ -4906,7 +4903,7 @@ impl MultiBufferSnapshot {
);
position.add_assign(&position_in_hunk);
} else if at_transform_end {
- diff_transforms.next(&());
+ diff_transforms.next();
continue;
}
}
@@ -4915,7 +4912,7 @@ impl MultiBufferSnapshot {
}
_ => {
if at_transform_end && anchor.diff_base_anchor.is_some() {
- diff_transforms.next(&());
+ diff_transforms.next();
continue;
}
let overshoot = excerpt_position - diff_transforms.start().0.0;
@@ -4933,9 +4930,9 @@ impl MultiBufferSnapshot {
.cursor::<(Option<&Locator>, ExcerptOffset)>(&());
let locator = self.excerpt_locator_for_id(anchor.excerpt_id);
- cursor.seek(&Some(locator), Bias::Left, &());
+ cursor.seek(&Some(locator), Bias::Left);
if cursor.item().is_none() {
- cursor.next(&());
+ cursor.next();
}
let mut position = cursor.start().1;
@@ -4975,7 +4972,7 @@ impl MultiBufferSnapshot {
let mut diff_transforms_cursor = self
.diff_transforms
.cursor::<(ExcerptDimension<D>, OutputDimension<D>)>(&());
- diff_transforms_cursor.next(&());
+ diff_transforms_cursor.next();
let mut summaries = Vec::new();
while let Some(anchor) = anchors.peek() {
@@ -4990,9 +4987,9 @@ impl MultiBufferSnapshot {
});
let locator = self.excerpt_locator_for_id(excerpt_id);
- cursor.seek_forward(locator, Bias::Left, &());
+ cursor.seek_forward(locator, Bias::Left);
if cursor.item().is_none() {
- cursor.next(&());
+ cursor.next();
}
let excerpt_start_position = D::from_text_summary(&cursor.start().text);
@@ -5022,11 +5019,8 @@ impl MultiBufferSnapshot {
}
if position > diff_transforms_cursor.start().0.0 {
- diff_transforms_cursor.seek_forward(
- &ExcerptDimension(position),
- Bias::Left,
- &(),
- );
+ diff_transforms_cursor
+ .seek_forward(&ExcerptDimension(position), Bias::Left);
}
summaries.push(self.resolve_summary_for_anchor(
@@ -5036,11 +5030,8 @@ impl MultiBufferSnapshot {
));
}
} else {
- diff_transforms_cursor.seek_forward(
- &ExcerptDimension(excerpt_start_position),
- Bias::Left,
- &(),
- );
+ diff_transforms_cursor
+ .seek_forward(&ExcerptDimension(excerpt_start_position), Bias::Left);
let position = self.resolve_summary_for_anchor(
&Anchor::max(),
excerpt_start_position,
@@ -5099,7 +5090,7 @@ impl MultiBufferSnapshot {
{
let mut anchors = anchors.into_iter().enumerate().peekable();
let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
- cursor.next(&());
+ cursor.next();
let mut result = Vec::new();
@@ -5108,10 +5099,10 @@ impl MultiBufferSnapshot {
// Find the location where this anchor's excerpt should be.
let old_locator = self.excerpt_locator_for_id(old_excerpt_id);
- cursor.seek_forward(&Some(old_locator), Bias::Left, &());
+ cursor.seek_forward(&Some(old_locator), Bias::Left);
if cursor.item().is_none() {
- cursor.next(&());
+ cursor.next();
}
let next_excerpt = cursor.item();
@@ -5211,13 +5202,13 @@ impl MultiBufferSnapshot {
// Find the given position in the diff transforms. Determine the corresponding
// offset in the excerpts, and whether the position is within a deleted hunk.
let mut diff_transforms = self.diff_transforms.cursor::<(usize, ExcerptOffset)>(&());
- diff_transforms.seek(&offset, Bias::Right, &());
+ diff_transforms.seek(&offset, Bias::Right);
if offset == diff_transforms.start().0 && bias == Bias::Left {
if let Some(prev_item) = diff_transforms.prev_item() {
match prev_item {
DiffTransform::DeletedHunk { .. } => {
- diff_transforms.prev(&());
+ diff_transforms.prev();
}
_ => {}
}
@@ -5260,13 +5251,13 @@ impl MultiBufferSnapshot {
let mut excerpts = self
.excerpts
.cursor::<(ExcerptOffset, Option<ExcerptId>)>(&());
- excerpts.seek(&excerpt_offset, Bias::Right, &());
+ excerpts.seek(&excerpt_offset, Bias::Right);
if excerpts.item().is_none() && excerpt_offset == excerpts.start().0 && bias == Bias::Left {
- excerpts.prev(&());
+ excerpts.prev();
}
if let Some(excerpt) = excerpts.item() {
let mut overshoot = excerpt_offset.saturating_sub(excerpts.start().0).value;
- if excerpt.has_trailing_newline && excerpt_offset == excerpts.end(&()).0 {
+ if excerpt.has_trailing_newline && excerpt_offset == excerpts.end().0 {
overshoot -= 1;
bias = Bias::Right;
}
@@ -5297,7 +5288,7 @@ impl MultiBufferSnapshot {
let excerpt_id = self.latest_excerpt_id(excerpt_id);
let locator = self.excerpt_locator_for_id(excerpt_id);
let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
- cursor.seek(locator, Bias::Left, &());
+ cursor.seek(locator, Bias::Left);
if let Some(excerpt) = cursor.item() {
if excerpt.id == excerpt_id {
let text_anchor = excerpt.clip_anchor(text_anchor);
@@ -5351,13 +5342,13 @@ impl MultiBufferSnapshot {
let mut excerpts = self
.excerpts
.cursor::<(Option<&Locator>, ExcerptDimension<usize>)>(&());
- excerpts.seek(&Some(start_locator), Bias::Left, &());
- excerpts.prev(&());
+ excerpts.seek(&Some(start_locator), Bias::Left);
+ excerpts.prev();
let mut diff_transforms = self.diff_transforms.cursor::<DiffTransforms<usize>>(&());
- diff_transforms.seek(&excerpts.start().1, Bias::Left, &());
- if diff_transforms.end(&()).excerpt_dimension < excerpts.start().1 {
- diff_transforms.next(&());
+ diff_transforms.seek(&excerpts.start().1, Bias::Left);
+ if diff_transforms.end().excerpt_dimension < excerpts.start().1 {
+ diff_transforms.next();
}
let excerpt = excerpts.item()?;
@@ -6193,7 +6184,7 @@ impl MultiBufferSnapshot {
Locator::max_ref()
} else {
let mut cursor = self.excerpt_ids.cursor::<ExcerptId>(&());
- cursor.seek(&id, Bias::Left, &());
+ cursor.seek(&id, Bias::Left);
if let Some(entry) = cursor.item() {
if entry.id == id {
return &entry.locator;
@@ -6229,7 +6220,7 @@ impl MultiBufferSnapshot {
let mut cursor = self.excerpt_ids.cursor::<ExcerptId>(&());
for id in sorted_ids {
- if cursor.seek_forward(&id, Bias::Left, &()) {
+ if cursor.seek_forward(&id, Bias::Left) {
locators.push(cursor.item().unwrap().locator.clone());
} else {
panic!("invalid excerpt id {:?}", id);
@@ -6253,16 +6244,16 @@ impl MultiBufferSnapshot {
.excerpts
.cursor::<(Option<&Locator>, ExcerptDimension<Point>)>(&());
let locator = self.excerpt_locator_for_id(excerpt_id);
- if cursor.seek(&Some(locator), Bias::Left, &()) {
+ if cursor.seek(&Some(locator), Bias::Left) {
let start = cursor.start().1.clone();
- let end = cursor.end(&()).1;
+ let end = cursor.end().1;
let mut diff_transforms = self
.diff_transforms
.cursor::<(ExcerptDimension<Point>, OutputDimension<Point>)>(&());
- diff_transforms.seek(&start, Bias::Left, &());
+ diff_transforms.seek(&start, Bias::Left);
let overshoot = start.0 - diff_transforms.start().0.0;
let start = diff_transforms.start().1.0 + overshoot;
- diff_transforms.seek(&end, Bias::Right, &());
+ diff_transforms.seek(&end, Bias::Right);
let overshoot = end.0 - diff_transforms.start().0.0;
let end = diff_transforms.start().1.0 + overshoot;
Some(start..end)
@@ -6274,7 +6265,7 @@ impl MultiBufferSnapshot {
pub fn buffer_range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<Range<text::Anchor>> {
let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
let locator = self.excerpt_locator_for_id(excerpt_id);
- if cursor.seek(&Some(locator), Bias::Left, &()) {
+ if cursor.seek(&Some(locator), Bias::Left) {
if let Some(excerpt) = cursor.item() {
return Some(excerpt.range.context.clone());
}
@@ -6285,7 +6276,7 @@ impl MultiBufferSnapshot {
fn excerpt(&self, excerpt_id: ExcerptId) -> Option<&Excerpt> {
let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
let locator = self.excerpt_locator_for_id(excerpt_id);
- cursor.seek(&Some(locator), Bias::Left, &());
+ cursor.seek(&Some(locator), Bias::Left);
if let Some(excerpt) = cursor.item() {
if excerpt.id == excerpt_id {
return Some(excerpt);
@@ -6333,7 +6324,7 @@ impl MultiBufferSnapshot {
let mut cursor = self.excerpts.cursor::<ExcerptSummary>(&());
let start_locator = self.excerpt_locator_for_id(range.start.excerpt_id);
let end_locator = self.excerpt_locator_for_id(range.end.excerpt_id);
- cursor.seek(start_locator, Bias::Left, &());
+ cursor.seek(start_locator, Bias::Left);
cursor
.take_while(move |excerpt| excerpt.locator <= *end_locator)
.flat_map(move |excerpt| {
@@ -6472,11 +6463,11 @@ where
fn seek(&mut self, position: &D) {
self.cached_region.take();
self.diff_transforms
- .seek(&OutputDimension(*position), Bias::Right, &());
+ .seek(&OutputDimension(*position), Bias::Right);
if self.diff_transforms.item().is_none()
&& *position == self.diff_transforms.start().output_dimension.0
{
- self.diff_transforms.prev(&());
+ self.diff_transforms.prev();
}
let mut excerpt_position = self.diff_transforms.start().excerpt_dimension.0;
@@ -6486,20 +6477,20 @@ where
}
self.excerpts
- .seek(&ExcerptDimension(excerpt_position), Bias::Right, &());
+ .seek(&ExcerptDimension(excerpt_position), Bias::Right);
if self.excerpts.item().is_none() && excerpt_position == self.excerpts.start().0 {
- self.excerpts.prev(&());
+ self.excerpts.prev();
}
}
fn seek_forward(&mut self, position: &D) {
self.cached_region.take();
self.diff_transforms
- .seek_forward(&OutputDimension(*position), Bias::Right, &());
+ .seek_forward(&OutputDimension(*position), Bias::Right);
if self.diff_transforms.item().is_none()
&& *position == self.diff_transforms.start().output_dimension.0
{
- self.diff_transforms.prev(&());
+ self.diff_transforms.prev();
}
let overshoot = *position - self.diff_transforms.start().output_dimension.0;
@@ -6509,31 +6500,30 @@ where
}
self.excerpts
- .seek_forward(&ExcerptDimension(excerpt_position), Bias::Right, &());
+ .seek_forward(&ExcerptDimension(excerpt_position), Bias::Right);
if self.excerpts.item().is_none() && excerpt_position == self.excerpts.start().0 {
- self.excerpts.prev(&());
+ self.excerpts.prev();
}
}
fn next_excerpt(&mut self) {
- self.excerpts.next(&());
+ self.excerpts.next();
self.seek_to_start_of_current_excerpt();
}
fn prev_excerpt(&mut self) {
- self.excerpts.prev(&());
+ self.excerpts.prev();
self.seek_to_start_of_current_excerpt();
}
fn seek_to_start_of_current_excerpt(&mut self) {
self.cached_region.take();
- self.diff_transforms
- .seek(self.excerpts.start(), Bias::Left, &());
- if self.diff_transforms.end(&()).excerpt_dimension == *self.excerpts.start()
+ self.diff_transforms.seek(self.excerpts.start(), Bias::Left);
+ if self.diff_transforms.end().excerpt_dimension == *self.excerpts.start()
&& self.diff_transforms.start().excerpt_dimension < *self.excerpts.start()
&& self.diff_transforms.next_item().is_some()
{
- self.diff_transforms.next(&());
+ self.diff_transforms.next();
}
}
@@ -6541,18 +6531,18 @@ where
self.cached_region.take();
match self
.diff_transforms
- .end(&())
+ .end()
.excerpt_dimension
- .cmp(&self.excerpts.end(&()))
+ .cmp(&self.excerpts.end())
{
- cmp::Ordering::Less => self.diff_transforms.next(&()),
- cmp::Ordering::Greater => self.excerpts.next(&()),
+ cmp::Ordering::Less => self.diff_transforms.next(),
+ cmp::Ordering::Greater => self.excerpts.next(),
cmp::Ordering::Equal => {
- self.diff_transforms.next(&());
- if self.diff_transforms.end(&()).excerpt_dimension > self.excerpts.end(&())
+ self.diff_transforms.next();
+ if self.diff_transforms.end().excerpt_dimension > self.excerpts.end()
|| self.diff_transforms.item().is_none()
{
- self.excerpts.next(&());
+ self.excerpts.next();
} else if let Some(DiffTransform::DeletedHunk { hunk_info, .. }) =
self.diff_transforms.item()
{
@@ -6561,7 +6551,7 @@ where
.item()
.map_or(false, |excerpt| excerpt.id != hunk_info.excerpt_id)
{
- self.excerpts.next(&());
+ self.excerpts.next();
}
}
}
@@ -6576,14 +6566,14 @@ where
.excerpt_dimension
.cmp(self.excerpts.start())
{
- cmp::Ordering::Less => self.excerpts.prev(&()),
- cmp::Ordering::Greater => self.diff_transforms.prev(&()),
+ cmp::Ordering::Less => self.excerpts.prev(),
+ cmp::Ordering::Greater => self.diff_transforms.prev(),
cmp::Ordering::Equal => {
- self.diff_transforms.prev(&());
+ self.diff_transforms.prev();
if self.diff_transforms.start().excerpt_dimension < *self.excerpts.start()
|| self.diff_transforms.item().is_none()
{
- self.excerpts.prev(&());
+ self.excerpts.prev();
}
}
}
@@ -6603,9 +6593,9 @@ where
return true;
}
- self.diff_transforms.prev(&());
+ self.diff_transforms.prev();
let prev_transform = self.diff_transforms.item();
- self.diff_transforms.next(&());
+ self.diff_transforms.next();
prev_transform.map_or(true, |next_transform| {
matches!(next_transform, DiffTransform::BufferContent { .. })
@@ -6613,9 +6603,9 @@ where
}
fn is_at_end_of_excerpt(&mut self) -> bool {
- if self.diff_transforms.end(&()).excerpt_dimension < self.excerpts.end(&()) {
+ if self.diff_transforms.end().excerpt_dimension < self.excerpts.end() {
return false;
- } else if self.diff_transforms.end(&()).excerpt_dimension > self.excerpts.end(&())
+ } else if self.diff_transforms.end().excerpt_dimension > self.excerpts.end()
|| self.diff_transforms.item().is_none()
{
return true;
@@ -6636,7 +6626,7 @@ where
let buffer = &excerpt.buffer;
let buffer_context_start = excerpt.range.context.start.summary::<D>(buffer);
let mut buffer_start = buffer_context_start;
- let overshoot = self.diff_transforms.end(&()).excerpt_dimension.0 - self.excerpts.start().0;
+ let overshoot = self.diff_transforms.end().excerpt_dimension.0 - self.excerpts.start().0;
buffer_start.add_assign(&overshoot);
Some(buffer_start)
}
@@ -6659,7 +6649,7 @@ where
let mut buffer_end = buffer_start;
buffer_end.add_assign(&buffer_range_len);
let start = self.diff_transforms.start().output_dimension.0;
- let end = self.diff_transforms.end(&()).output_dimension.0;
+ let end = self.diff_transforms.end().output_dimension.0;
return Some(MultiBufferRegion {
buffer,
excerpt,
@@ -6693,16 +6683,16 @@ where
let mut end;
let mut buffer_end;
let has_trailing_newline;
- if self.diff_transforms.end(&()).excerpt_dimension.0 < self.excerpts.end(&()).0 {
+ if self.diff_transforms.end().excerpt_dimension.0 < self.excerpts.end().0 {
let overshoot =
- self.diff_transforms.end(&()).excerpt_dimension.0 - self.excerpts.start().0;
- end = self.diff_transforms.end(&()).output_dimension.0;
+ self.diff_transforms.end().excerpt_dimension.0 - self.excerpts.start().0;
+ end = self.diff_transforms.end().output_dimension.0;
buffer_end = buffer_context_start;
buffer_end.add_assign(&overshoot);
has_trailing_newline = false;
} else {
let overshoot =
- self.excerpts.end(&()).0 - self.diff_transforms.start().excerpt_dimension.0;
+ self.excerpts.end().0 - self.diff_transforms.start().excerpt_dimension.0;
end = self.diff_transforms.start().output_dimension.0;
end.add_assign(&overshoot);
buffer_end = excerpt.range.context.end.summary::<D>(buffer);
@@ -7086,11 +7076,11 @@ impl<'a> MultiBufferExcerpt<'a> {
/// Maps a range within the [`MultiBuffer`] to a range within the [`Buffer`]
pub fn map_range_to_buffer(&mut self, range: Range<usize>) -> Range<usize> {
self.diff_transforms
- .seek(&OutputDimension(range.start), Bias::Right, &());
+ .seek(&OutputDimension(range.start), Bias::Right);
let start = self.map_offset_to_buffer_internal(range.start);
let end = if range.end > range.start {
self.diff_transforms
- .seek_forward(&OutputDimension(range.end), Bias::Right, &());
+ .seek_forward(&OutputDimension(range.end), Bias::Right);
self.map_offset_to_buffer_internal(range.end)
} else {
start
@@ -7123,7 +7113,7 @@ impl<'a> MultiBufferExcerpt<'a> {
}
let overshoot = buffer_range.start - self.buffer_offset;
let excerpt_offset = ExcerptDimension(self.excerpt_offset.0 + overshoot);
- self.diff_transforms.seek(&excerpt_offset, Bias::Right, &());
+ self.diff_transforms.seek(&excerpt_offset, Bias::Right);
if excerpt_offset.0 < self.diff_transforms.start().excerpt_dimension.0 {
log::warn!(
"Attempting to map a range from a buffer offset that starts before the current buffer offset"
@@ -7137,7 +7127,7 @@ impl<'a> MultiBufferExcerpt<'a> {
let overshoot = buffer_range.end - self.buffer_offset;
let excerpt_offset = ExcerptDimension(self.excerpt_offset.0 + overshoot);
self.diff_transforms
- .seek_forward(&excerpt_offset, Bias::Right, &());
+ .seek_forward(&excerpt_offset, Bias::Right);
let overshoot = excerpt_offset.0 - self.diff_transforms.start().excerpt_dimension.0;
self.diff_transforms.start().output_dimension.0 + overshoot
} else {
@@ -7509,7 +7499,7 @@ impl Iterator for MultiBufferRows<'_> {
if let Some(next_region) = self.cursor.region() {
region = next_region;
} else {
- if self.point == self.cursor.diff_transforms.end(&()).output_dimension.0 {
+ if self.point == self.cursor.diff_transforms.end().output_dimension.0 {
let multibuffer_row = MultiBufferRow(self.point.row);
let last_excerpt = self
.cursor
@@ -7615,14 +7605,14 @@ impl<'a> MultiBufferChunks<'a> {
}
pub fn seek(&mut self, range: Range<usize>) {
- self.diff_transforms.seek(&range.end, Bias::Right, &());
+ self.diff_transforms.seek(&range.end, Bias::Right);
let mut excerpt_end = self.diff_transforms.start().1;
if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
let overshoot = range.end - self.diff_transforms.start().0;
excerpt_end.value += overshoot;
}
- self.diff_transforms.seek(&range.start, Bias::Right, &());
+ self.diff_transforms.seek(&range.start, Bias::Right);
let mut excerpt_start = self.diff_transforms.start().1;
if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
let overshoot = range.start - self.diff_transforms.start().0;
@@ -7636,7 +7626,7 @@ impl<'a> MultiBufferChunks<'a> {
fn seek_to_excerpt_offset_range(&mut self, new_range: Range<ExcerptOffset>) {
self.excerpt_offset_range = new_range.clone();
- self.excerpts.seek(&new_range.start, Bias::Right, &());
+ self.excerpts.seek(&new_range.start, Bias::Right);
if let Some(excerpt) = self.excerpts.item() {
let excerpt_start = *self.excerpts.start();
if let Some(excerpt_chunks) = self
@@ -7669,7 +7659,7 @@ impl<'a> MultiBufferChunks<'a> {
self.excerpt_offset_range.start.value += chunk.text.len();
return Some(chunk);
} else {
- self.excerpts.next(&());
+ self.excerpts.next();
let excerpt = self.excerpts.item()?;
self.excerpt_chunks = Some(excerpt.chunks_in_range(
0..(self.excerpt_offset_range.end - *self.excerpts.start()).value,
@@ -7712,12 +7702,12 @@ impl<'a> Iterator for MultiBufferChunks<'a> {
if self.range.start >= self.range.end {
return None;
}
- if self.range.start == self.diff_transforms.end(&()).0 {
- self.diff_transforms.next(&());
+ if self.range.start == self.diff_transforms.end().0 {
+ self.diff_transforms.next();
}
let diff_transform_start = self.diff_transforms.start().0;
- let diff_transform_end = self.diff_transforms.end(&()).0;
+ let diff_transform_end = self.diff_transforms.end().0;
debug_assert!(self.range.start < diff_transform_end);
let diff_transform = self.diff_transforms.item()?;
@@ -132,12 +132,12 @@ impl NotificationStore {
}
let ix = count - 1 - ix;
let mut cursor = self.notifications.cursor::<Count>(&());
- cursor.seek(&Count(ix), Bias::Right, &());
+ cursor.seek(&Count(ix), Bias::Right);
cursor.item()
}
pub fn notification_for_id(&self, id: u64) -> Option<&NotificationEntry> {
let mut cursor = self.notifications.cursor::<NotificationId>(&());
- cursor.seek(&NotificationId(id), Bias::Left, &());
+ cursor.seek(&NotificationId(id), Bias::Left);
if let Some(item) = cursor.item() {
if item.id == id {
return Some(item);
@@ -365,7 +365,7 @@ impl NotificationStore {
let mut old_range = 0..0;
for (i, (id, new_notification)) in notifications.into_iter().enumerate() {
- new_notifications.append(cursor.slice(&NotificationId(id), Bias::Left, &()), &());
+ new_notifications.append(cursor.slice(&NotificationId(id), Bias::Left), &());
if i == 0 {
old_range.start = cursor.start().1.0;
@@ -374,7 +374,7 @@ impl NotificationStore {
let old_notification = cursor.item();
if let Some(old_notification) = old_notification {
if old_notification.id == id {
- cursor.next(&());
+ cursor.next();
if let Some(new_notification) = &new_notification {
if new_notification.is_read {
@@ -403,7 +403,7 @@ impl NotificationStore {
old_range.end = cursor.start().1.0;
let new_count = new_notifications.summary().count - old_range.start;
- new_notifications.append(cursor.suffix(&()), &());
+ new_notifications.append(cursor.suffix(), &());
drop(cursor);
self.notifications = new_notifications;
@@ -4279,7 +4279,7 @@ impl Repository {
for (repo_path, status) in &*statuses.entries {
changed_paths.remove(repo_path);
- if cursor.seek_forward(&PathTarget::Path(repo_path), Bias::Left, &()) {
+ if cursor.seek_forward(&PathTarget::Path(repo_path), Bias::Left) {
if cursor.item().is_some_and(|entry| entry.status == *status) {
continue;
}
@@ -4292,7 +4292,7 @@ impl Repository {
}
let mut cursor = prev_statuses.cursor::<PathProgress>(&());
for path in changed_paths.into_iter() {
- if cursor.seek_forward(&PathTarget::Path(&path), Bias::Left, &()) {
+ if cursor.seek_forward(&PathTarget::Path(&path), Bias::Left) {
changed_path_statuses.push(Edit::Remove(PathKey(path.0)));
}
}
@@ -72,14 +72,13 @@ impl<'a> GitTraversal<'a> {
if entry.is_dir() {
let mut statuses = statuses.clone();
- statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left, &());
- let summary =
- statuses.summary(&PathTarget::Successor(repo_path.as_ref()), Bias::Left, &());
+ statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left);
+ let summary = statuses.summary(&PathTarget::Successor(repo_path.as_ref()), Bias::Left);
self.current_entry_summary = Some(summary);
} else if entry.is_file() {
// For a file entry, park the cursor on the corresponding status
- if statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left, &()) {
+ if statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left) {
// TODO: Investigate statuses.item() being None here.
self.current_entry_summary = statuses.item().map(|item| item.status.into());
} else {
@@ -41,9 +41,9 @@ impl Rope {
self.push_chunk(chunk.as_slice());
let mut chunks = rope.chunks.cursor::<()>(&());
- chunks.next(&());
- chunks.next(&());
- self.chunks.append(chunks.suffix(&()), &());
+ chunks.next();
+ chunks.next();
+ self.chunks.append(chunks.suffix(), &());
self.check_invariants();
return;
}
@@ -283,7 +283,7 @@ impl Rope {
return self.summary().len_utf16;
}
let mut cursor = self.chunks.cursor::<(usize, OffsetUtf16)>(&());
- cursor.seek(&offset, Bias::Left, &());
+ cursor.seek(&offset, Bias::Left);
let overshoot = offset - cursor.start().0;
cursor.start().1
+ cursor.item().map_or(Default::default(), |chunk| {
@@ -296,7 +296,7 @@ impl Rope {
return self.summary().len;
}
let mut cursor = self.chunks.cursor::<(OffsetUtf16, usize)>(&());
- cursor.seek(&offset, Bias::Left, &());
+ cursor.seek(&offset, Bias::Left);
let overshoot = offset - cursor.start().0;
cursor.start().1
+ cursor.item().map_or(Default::default(), |chunk| {
@@ -309,7 +309,7 @@ impl Rope {
return self.summary().lines;
}
let mut cursor = self.chunks.cursor::<(usize, Point)>(&());
- cursor.seek(&offset, Bias::Left, &());
+ cursor.seek(&offset, Bias::Left);
let overshoot = offset - cursor.start().0;
cursor.start().1
+ cursor.item().map_or(Point::zero(), |chunk| {
@@ -322,7 +322,7 @@ impl Rope {
return self.summary().lines_utf16();
}
let mut cursor = self.chunks.cursor::<(usize, PointUtf16)>(&());
- cursor.seek(&offset, Bias::Left, &());
+ cursor.seek(&offset, Bias::Left);
let overshoot = offset - cursor.start().0;
cursor.start().1
+ cursor.item().map_or(PointUtf16::zero(), |chunk| {
@@ -335,7 +335,7 @@ impl Rope {
return self.summary().lines_utf16();
}
let mut cursor = self.chunks.cursor::<(Point, PointUtf16)>(&());
- cursor.seek(&point, Bias::Left, &());
+ cursor.seek(&point, Bias::Left);
let overshoot = point - cursor.start().0;
cursor.start().1
+ cursor.item().map_or(PointUtf16::zero(), |chunk| {
@@ -348,7 +348,7 @@ impl Rope {
return self.summary().len;
}
let mut cursor = self.chunks.cursor::<(Point, usize)>(&());
- cursor.seek(&point, Bias::Left, &());
+ cursor.seek(&point, Bias::Left);
let overshoot = point - cursor.start().0;
cursor.start().1
+ cursor
@@ -369,7 +369,7 @@ impl Rope {
return self.summary().len;
}
let mut cursor = self.chunks.cursor::<(PointUtf16, usize)>(&());
- cursor.seek(&point, Bias::Left, &());
+ cursor.seek(&point, Bias::Left);
let overshoot = point - cursor.start().0;
cursor.start().1
+ cursor.item().map_or(0, |chunk| {
@@ -382,7 +382,7 @@ impl Rope {
return self.summary().lines;
}
let mut cursor = self.chunks.cursor::<(PointUtf16, Point)>(&());
- cursor.seek(&point.0, Bias::Left, &());
+ cursor.seek(&point.0, Bias::Left);
let overshoot = Unclipped(point.0 - cursor.start().0);
cursor.start().1
+ cursor.item().map_or(Point::zero(), |chunk| {
@@ -392,7 +392,7 @@ impl Rope {
pub fn clip_offset(&self, mut offset: usize, bias: Bias) -> usize {
let mut cursor = self.chunks.cursor::<usize>(&());
- cursor.seek(&offset, Bias::Left, &());
+ cursor.seek(&offset, Bias::Left);
if let Some(chunk) = cursor.item() {
let mut ix = offset - cursor.start();
while !chunk.text.is_char_boundary(ix) {
@@ -415,7 +415,7 @@ impl Rope {
pub fn clip_offset_utf16(&self, offset: OffsetUtf16, bias: Bias) -> OffsetUtf16 {
let mut cursor = self.chunks.cursor::<OffsetUtf16>(&());
- cursor.seek(&offset, Bias::Right, &());
+ cursor.seek(&offset, Bias::Right);
if let Some(chunk) = cursor.item() {
let overshoot = offset - cursor.start();
*cursor.start() + chunk.as_slice().clip_offset_utf16(overshoot, bias)
@@ -426,7 +426,7 @@ impl Rope {
pub fn clip_point(&self, point: Point, bias: Bias) -> Point {
let mut cursor = self.chunks.cursor::<Point>(&());
- cursor.seek(&point, Bias::Right, &());
+ cursor.seek(&point, Bias::Right);
if let Some(chunk) = cursor.item() {
let overshoot = point - cursor.start();
*cursor.start() + chunk.as_slice().clip_point(overshoot, bias)
@@ -437,7 +437,7 @@ impl Rope {
pub fn clip_point_utf16(&self, point: Unclipped<PointUtf16>, bias: Bias) -> PointUtf16 {
let mut cursor = self.chunks.cursor::<PointUtf16>(&());
- cursor.seek(&point.0, Bias::Right, &());
+ cursor.seek(&point.0, Bias::Right);
if let Some(chunk) = cursor.item() {
let overshoot = Unclipped(point.0 - cursor.start());
*cursor.start() + chunk.as_slice().clip_point_utf16(overshoot, bias)
@@ -450,10 +450,6 @@ impl Rope {
self.clip_point(Point::new(row, u32::MAX), Bias::Left)
.column
}
-
- pub fn ptr_eq(&self, other: &Self) -> bool {
- self.chunks.ptr_eq(&other.chunks)
- }
}
impl<'a> From<&'a str> for Rope {
@@ -514,7 +510,7 @@ pub struct Cursor<'a> {
impl<'a> Cursor<'a> {
pub fn new(rope: &'a Rope, offset: usize) -> Self {
let mut chunks = rope.chunks.cursor(&());
- chunks.seek(&offset, Bias::Right, &());
+ chunks.seek(&offset, Bias::Right);
Self {
rope,
chunks,
@@ -525,7 +521,7 @@ impl<'a> Cursor<'a> {
pub fn seek_forward(&mut self, end_offset: usize) {
debug_assert!(end_offset >= self.offset);
- self.chunks.seek_forward(&end_offset, Bias::Right, &());
+ self.chunks.seek_forward(&end_offset, Bias::Right);
self.offset = end_offset;
}
@@ -540,14 +536,14 @@ 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_chunk(start_chunk.slice(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, Bias::Right, &()),
+ chunks: self.chunks.slice(&end_offset, Bias::Right),
});
if let Some(end_chunk) = self.chunks.item() {
let end_ix = end_offset - self.chunks.start();
@@ -565,13 +561,13 @@ impl<'a> Cursor<'a> {
let mut summary = D::zero(&());
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.add_assign(&D::from_chunk(start_chunk.slice(start_ix..end_ix)));
}
- if end_offset > self.chunks.end(&()) {
- self.chunks.next(&());
- summary.add_assign(&self.chunks.summary(&end_offset, Bias::Right, &()));
+ if end_offset > self.chunks.end() {
+ self.chunks.next();
+ summary.add_assign(&self.chunks.summary(&end_offset, Bias::Right));
if let Some(end_chunk) = self.chunks.item() {
let end_ix = end_offset - self.chunks.start();
summary.add_assign(&D::from_chunk(end_chunk.slice(0..end_ix)));
@@ -603,10 +599,10 @@ impl<'a> Chunks<'a> {
pub fn new(rope: &'a Rope, range: Range<usize>, reversed: bool) -> Self {
let mut chunks = rope.chunks.cursor(&());
let offset = if reversed {
- chunks.seek(&range.end, Bias::Left, &());
+ chunks.seek(&range.end, Bias::Left);
range.end
} else {
- chunks.seek(&range.start, Bias::Right, &());
+ chunks.seek(&range.start, Bias::Right);
range.start
};
Self {
@@ -642,10 +638,10 @@ impl<'a> Chunks<'a> {
Bias::Right
};
- if offset >= self.chunks.end(&()) {
- self.chunks.seek_forward(&offset, bias, &());
+ if offset >= self.chunks.end() {
+ self.chunks.seek_forward(&offset, bias);
} else {
- self.chunks.seek(&offset, bias, &());
+ self.chunks.seek(&offset, bias);
}
self.offset = offset;
@@ -674,25 +670,25 @@ impl<'a> Chunks<'a> {
found = self.offset <= self.range.end;
} else {
self.chunks
- .search_forward(|summary| summary.text.lines.row > 0, &());
+ .search_forward(|summary| summary.text.lines.row > 0);
self.offset = *self.chunks.start();
if let Some(newline_ix) = self.peek().and_then(|chunk| chunk.find('\n')) {
self.offset += newline_ix + 1;
found = self.offset <= self.range.end;
} else {
- self.offset = self.chunks.end(&());
+ self.offset = self.chunks.end();
}
}
- if self.offset == self.chunks.end(&()) {
+ if self.offset == self.chunks.end() {
self.next();
}
}
if self.offset > self.range.end {
self.offset = cmp::min(self.offset, self.range.end);
- self.chunks.seek(&self.offset, Bias::Right, &());
+ self.chunks.seek(&self.offset, Bias::Right);
}
found
@@ -711,7 +707,7 @@ impl<'a> Chunks<'a> {
let initial_offset = self.offset;
if self.offset == *self.chunks.start() {
- self.chunks.prev(&());
+ self.chunks.prev();
}
if let Some(chunk) = self.chunks.item() {
@@ -729,14 +725,14 @@ impl<'a> Chunks<'a> {
}
self.chunks
- .search_backward(|summary| summary.text.lines.row > 0, &());
+ .search_backward(|summary| summary.text.lines.row > 0);
self.offset = *self.chunks.start();
if let Some(chunk) = self.chunks.item() {
if let Some(newline_ix) = chunk.text.rfind('\n') {
self.offset += newline_ix + 1;
if self.offset_is_valid() {
- if self.offset == self.chunks.end(&()) {
- self.chunks.next(&());
+ if self.offset == self.chunks.end() {
+ self.chunks.next();
}
return true;
@@ -746,7 +742,7 @@ impl<'a> Chunks<'a> {
if !self.offset_is_valid() || self.chunks.item().is_none() {
self.offset = self.range.start;
- self.chunks.seek(&self.offset, Bias::Right, &());
+ self.chunks.seek(&self.offset, Bias::Right);
}
self.offset < initial_offset && self.offset == 0
@@ -765,7 +761,7 @@ impl<'a> Chunks<'a> {
slice_start..slice_end
} else {
let slice_start = self.offset - chunk_start;
- let slice_end = cmp::min(self.chunks.end(&()), self.range.end) - chunk_start;
+ let slice_end = cmp::min(self.chunks.end(), self.range.end) - chunk_start;
slice_start..slice_end
};
@@ -825,12 +821,12 @@ impl<'a> Iterator for Chunks<'a> {
if self.reversed {
self.offset -= chunk.len();
if self.offset <= *self.chunks.start() {
- self.chunks.prev(&());
+ self.chunks.prev();
}
} else {
self.offset += chunk.len();
- if self.offset >= self.chunks.end(&()) {
- self.chunks.next(&());
+ if self.offset >= self.chunks.end() {
+ self.chunks.next();
}
}
@@ -848,9 +844,9 @@ impl<'a> Bytes<'a> {
pub fn new(rope: &'a Rope, range: Range<usize>, reversed: bool) -> Self {
let mut chunks = rope.chunks.cursor(&());
if reversed {
- chunks.seek(&range.end, Bias::Left, &());
+ chunks.seek(&range.end, Bias::Left);
} else {
- chunks.seek(&range.start, Bias::Right, &());
+ chunks.seek(&range.start, Bias::Right);
}
Self {
chunks,
@@ -861,7 +857,7 @@ impl<'a> Bytes<'a> {
pub fn peek(&self) -> Option<&'a [u8]> {
let chunk = self.chunks.item()?;
- if self.reversed && self.range.start >= self.chunks.end(&()) {
+ if self.reversed && self.range.start >= self.chunks.end() {
return None;
}
let chunk_start = *self.chunks.start();
@@ -881,9 +877,9 @@ impl<'a> Iterator for Bytes<'a> {
let result = self.peek();
if result.is_some() {
if self.reversed {
- self.chunks.prev(&());
+ self.chunks.prev();
} else {
- self.chunks.next(&());
+ self.chunks.next();
}
}
result
@@ -905,9 +901,9 @@ impl io::Read for Bytes<'_> {
if len == chunk.len() {
if self.reversed {
- self.chunks.prev(&());
+ self.chunks.prev();
} else {
- self.chunks.next(&());
+ self.chunks.next();
}
}
Ok(len)
@@ -25,6 +25,7 @@ pub struct Cursor<'a, T: Item, D> {
position: D,
did_seek: bool,
at_end: bool,
+ cx: &'a <T::Summary as Summary>::Context,
}
impl<T: Item + fmt::Debug, D: fmt::Debug> fmt::Debug for Cursor<'_, T, D>
@@ -52,21 +53,22 @@ where
T: Item,
D: Dimension<'a, T::Summary>,
{
- pub fn new(tree: &'a SumTree<T>, cx: &<T::Summary as Summary>::Context) -> Self {
+ pub fn new(tree: &'a SumTree<T>, cx: &'a <T::Summary as Summary>::Context) -> Self {
Self {
tree,
stack: ArrayVec::new(),
position: D::zero(cx),
did_seek: false,
at_end: tree.is_empty(),
+ cx,
}
}
- fn reset(&mut self, cx: &<T::Summary as Summary>::Context) {
+ fn reset(&mut self) {
self.did_seek = false;
self.at_end = self.tree.is_empty();
self.stack.truncate(0);
- self.position = D::zero(cx);
+ self.position = D::zero(self.cx);
}
pub fn start(&self) -> &D {
@@ -74,10 +76,10 @@ where
}
#[track_caller]
- pub fn end(&self, cx: &<T::Summary as Summary>::Context) -> D {
+ pub fn end(&self) -> D {
if let Some(item_summary) = self.item_summary() {
let mut end = self.start().clone();
- end.add_summary(item_summary, cx);
+ end.add_summary(item_summary, self.cx);
end
} else {
self.start().clone()
@@ -202,12 +204,12 @@ where
}
#[track_caller]
- pub fn prev(&mut self, cx: &<T::Summary as Summary>::Context) {
- self.search_backward(|_| true, cx)
+ pub fn prev(&mut self) {
+ self.search_backward(|_| true)
}
#[track_caller]
- pub fn search_backward<F>(&mut self, mut filter_node: F, cx: &<T::Summary as Summary>::Context)
+ pub fn search_backward<F>(&mut self, mut filter_node: F)
where
F: FnMut(&T::Summary) -> bool,
{
@@ -217,13 +219,13 @@ where
}
if self.at_end {
- self.position = D::zero(cx);
+ self.position = D::zero(self.cx);
self.at_end = self.tree.is_empty();
if !self.tree.is_empty() {
self.stack.push(StackEntry {
tree: self.tree,
index: self.tree.0.child_summaries().len(),
- position: D::from_summary(self.tree.summary(), cx),
+ position: D::from_summary(self.tree.summary(), self.cx),
});
}
}
@@ -233,7 +235,7 @@ where
if let Some(StackEntry { position, .. }) = self.stack.iter().rev().nth(1) {
self.position = position.clone();
} else {
- self.position = D::zero(cx);
+ self.position = D::zero(self.cx);
}
let entry = self.stack.last_mut().unwrap();
@@ -247,7 +249,7 @@ where
}
for summary in &entry.tree.0.child_summaries()[..entry.index] {
- self.position.add_summary(summary, cx);
+ self.position.add_summary(summary, self.cx);
}
entry.position = self.position.clone();
@@ -257,7 +259,7 @@ where
if descending {
let tree = &child_trees[entry.index];
self.stack.push(StackEntry {
- position: D::zero(cx),
+ position: D::zero(self.cx),
tree,
index: tree.0.child_summaries().len() - 1,
})
@@ -273,12 +275,12 @@ where
}
#[track_caller]
- pub fn next(&mut self, cx: &<T::Summary as Summary>::Context) {
- self.search_forward(|_| true, cx)
+ pub fn next(&mut self) {
+ self.search_forward(|_| true)
}
#[track_caller]
- pub fn search_forward<F>(&mut self, mut filter_node: F, cx: &<T::Summary as Summary>::Context)
+ pub fn search_forward<F>(&mut self, mut filter_node: F)
where
F: FnMut(&T::Summary) -> bool,
{
@@ -289,7 +291,7 @@ where
self.stack.push(StackEntry {
tree: self.tree,
index: 0,
- position: D::zero(cx),
+ position: D::zero(self.cx),
});
descend = true;
}
@@ -316,8 +318,8 @@ where
break;
} else {
entry.index += 1;
- entry.position.add_summary(next_summary, cx);
- self.position.add_summary(next_summary, cx);
+ entry.position.add_summary(next_summary, self.cx);
+ self.position.add_summary(next_summary, self.cx);
}
}
@@ -327,8 +329,8 @@ where
if !descend {
let item_summary = &item_summaries[entry.index];
entry.index += 1;
- entry.position.add_summary(item_summary, cx);
- self.position.add_summary(item_summary, cx);
+ entry.position.add_summary(item_summary, self.cx);
+ self.position.add_summary(item_summary, self.cx);
}
loop {
@@ -337,8 +339,8 @@ where
return;
} else {
entry.index += 1;
- entry.position.add_summary(next_item_summary, cx);
- self.position.add_summary(next_item_summary, cx);
+ entry.position.add_summary(next_item_summary, self.cx);
+ self.position.add_summary(next_item_summary, self.cx);
}
} else {
break None;
@@ -380,71 +382,51 @@ where
D: Dimension<'a, T::Summary>,
{
#[track_caller]
- pub fn seek<Target>(
- &mut self,
- pos: &Target,
- bias: Bias,
- cx: &<T::Summary as Summary>::Context,
- ) -> bool
+ pub fn seek<Target>(&mut self, pos: &Target, bias: Bias) -> bool
where
Target: SeekTarget<'a, T::Summary, D>,
{
- self.reset(cx);
- self.seek_internal(pos, bias, &mut (), cx)
+ self.reset();
+ self.seek_internal(pos, bias, &mut ())
}
#[track_caller]
- pub fn seek_forward<Target>(
- &mut self,
- pos: &Target,
- bias: Bias,
- cx: &<T::Summary as Summary>::Context,
- ) -> bool
+ pub fn seek_forward<Target>(&mut self, pos: &Target, bias: Bias) -> bool
where
Target: SeekTarget<'a, T::Summary, D>,
{
- self.seek_internal(pos, bias, &mut (), cx)
+ self.seek_internal(pos, bias, &mut ())
}
/// Advances the cursor and returns traversed items as a tree.
#[track_caller]
- pub fn slice<Target>(
- &mut self,
- end: &Target,
- bias: Bias,
- cx: &<T::Summary as Summary>::Context,
- ) -> SumTree<T>
+ pub fn slice<Target>(&mut self, end: &Target, bias: Bias) -> SumTree<T>
where
Target: SeekTarget<'a, T::Summary, D>,
{
let mut slice = SliceSeekAggregate {
- tree: SumTree::new(cx),
+ tree: SumTree::new(self.cx),
leaf_items: ArrayVec::new(),
leaf_item_summaries: ArrayVec::new(),
- leaf_summary: <T::Summary as Summary>::zero(cx),
+ leaf_summary: <T::Summary as Summary>::zero(self.cx),
};
- self.seek_internal(end, bias, &mut slice, cx);
+ self.seek_internal(end, bias, &mut slice);
slice.tree
}
#[track_caller]
- pub fn suffix(&mut self, cx: &<T::Summary as Summary>::Context) -> SumTree<T> {
- self.slice(&End::new(), Bias::Right, cx)
+ pub fn suffix(&mut self) -> SumTree<T> {
+ self.slice(&End::new(), Bias::Right)
}
#[track_caller]
- pub fn summary<Target, Output>(
- &mut self,
- end: &Target,
- bias: Bias,
- cx: &<T::Summary as Summary>::Context,
- ) -> Output
+ pub fn summary<Target, Output>(&mut self, end: &Target, bias: Bias) -> Output
where
Target: SeekTarget<'a, T::Summary, D>,
Output: Dimension<'a, T::Summary>,
{
- let mut summary = SummarySeekAggregate(Output::zero(cx));
- self.seek_internal(end, bias, &mut summary, cx);
+ let mut summary = SummarySeekAggregate(Output::zero(self.cx));
+ self.seek_internal(end, bias, &mut summary);
summary.0
}
@@ -455,10 +437,9 @@ where
target: &dyn SeekTarget<'a, T::Summary, D>,
bias: Bias,
aggregate: &mut dyn SeekAggregate<'a, T>,
- cx: &<T::Summary as Summary>::Context,
) -> bool {
assert!(
- target.cmp(&self.position, cx) >= Ordering::Equal,
+ target.cmp(&self.position, self.cx) >= Ordering::Equal,
"cannot seek backward",
);
@@ -467,7 +448,7 @@ where
self.stack.push(StackEntry {
tree: self.tree,
index: 0,
- position: D::zero(cx),
+ position: D::zero(self.cx),
});
}
@@ -489,14 +470,14 @@ where
.zip(&child_summaries[entry.index..])
{
let mut child_end = self.position.clone();
- child_end.add_summary(child_summary, cx);
+ child_end.add_summary(child_summary, self.cx);
- let comparison = target.cmp(&child_end, cx);
+ let comparison = target.cmp(&child_end, self.cx);
if comparison == Ordering::Greater
|| (comparison == Ordering::Equal && bias == Bias::Right)
{
self.position = child_end;
- aggregate.push_tree(child_tree, child_summary, cx);
+ aggregate.push_tree(child_tree, child_summary, self.cx);
entry.index += 1;
entry.position = self.position.clone();
} else {
@@ -522,22 +503,22 @@ where
.zip(&item_summaries[entry.index..])
{
let mut child_end = self.position.clone();
- child_end.add_summary(item_summary, cx);
+ child_end.add_summary(item_summary, self.cx);
- let comparison = target.cmp(&child_end, cx);
+ let comparison = target.cmp(&child_end, self.cx);
if comparison == Ordering::Greater
|| (comparison == Ordering::Equal && bias == Bias::Right)
{
self.position = child_end;
- aggregate.push_item(item, item_summary, cx);
+ aggregate.push_item(item, item_summary, self.cx);
entry.index += 1;
} else {
- aggregate.end_leaf(cx);
+ aggregate.end_leaf(self.cx);
break 'outer;
}
}
- aggregate.end_leaf(cx);
+ aggregate.end_leaf(self.cx);
}
}
@@ -551,11 +532,11 @@ where
let mut end = self.position.clone();
if bias == Bias::Left {
if let Some(summary) = self.item_summary() {
- end.add_summary(summary, cx);
+ end.add_summary(summary, self.cx);
}
}
- target.cmp(&end, cx) == Ordering::Equal
+ target.cmp(&end, self.cx) == Ordering::Equal
}
}
@@ -624,21 +605,19 @@ impl<'a, T: Item> Iterator for Iter<'a, T> {
}
}
-impl<'a, T, S, D> Iterator for Cursor<'a, T, D>
+impl<'a, T: Item, D> Iterator for Cursor<'a, T, D>
where
- T: Item<Summary = S>,
- S: Summary<Context = ()>,
D: Dimension<'a, T::Summary>,
{
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
if !self.did_seek {
- self.next(&());
+ self.next();
}
if let Some(item) = self.item() {
- self.next(&());
+ self.next();
Some(item)
} else {
None
@@ -651,7 +630,7 @@ pub struct FilterCursor<'a, F, T: Item, D> {
filter_node: F,
}
-impl<'a, F, T, D> FilterCursor<'a, F, T, D>
+impl<'a, F, T: Item, D> FilterCursor<'a, F, T, D>
where
F: FnMut(&T::Summary) -> bool,
T: Item,
@@ -659,7 +638,7 @@ where
{
pub fn new(
tree: &'a SumTree<T>,
- cx: &<T::Summary as Summary>::Context,
+ cx: &'a <T::Summary as Summary>::Context,
filter_node: F,
) -> Self {
let cursor = tree.cursor::<D>(cx);
@@ -673,8 +652,8 @@ where
self.cursor.start()
}
- pub fn end(&self, cx: &<T::Summary as Summary>::Context) -> D {
- self.cursor.end(cx)
+ pub fn end(&self) -> D {
+ self.cursor.end()
}
pub fn item(&self) -> Option<&'a T> {
@@ -685,31 +664,29 @@ where
self.cursor.item_summary()
}
- pub fn next(&mut self, cx: &<T::Summary as Summary>::Context) {
- self.cursor.search_forward(&mut self.filter_node, cx);
+ pub fn next(&mut self) {
+ self.cursor.search_forward(&mut self.filter_node);
}
- pub fn prev(&mut self, cx: &<T::Summary as Summary>::Context) {
- self.cursor.search_backward(&mut self.filter_node, cx);
+ pub fn prev(&mut self) {
+ self.cursor.search_backward(&mut self.filter_node);
}
}
-impl<'a, F, T, S, U> Iterator for FilterCursor<'a, F, T, U>
+impl<'a, F, T: Item, U> Iterator for FilterCursor<'a, F, T, U>
where
F: FnMut(&T::Summary) -> bool,
- T: Item<Summary = S>,
- S: Summary<Context = ()>, //Context for the summary must be unit type, as .next() doesn't take arguments
U: Dimension<'a, T::Summary>,
{
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
if !self.cursor.did_seek {
- self.next(&());
+ self.next();
}
if let Some(item) = self.item() {
- self.cursor.search_forward(&mut self.filter_node, &());
+ self.cursor.search_forward(&mut self.filter_node);
Some(item)
} else {
None
@@ -795,3 +772,23 @@ where
self.0.add_summary(summary, cx);
}
}
+
+struct End<D>(PhantomData<D>);
+
+impl<D> End<D> {
+ fn new() -> Self {
+ Self(PhantomData)
+ }
+}
+
+impl<'a, S: Summary, D: Dimension<'a, S>> SeekTarget<'a, S, D> for End<D> {
+ fn cmp(&self, _: &D, _: &S::Context) -> Ordering {
+ Ordering::Greater
+ }
+}
+
+impl<D> fmt::Debug for End<D> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_tuple("End").finish()
+ }
+}
@@ -38,7 +38,6 @@ pub trait Summary: Clone {
type Context;
fn zero(cx: &Self::Context) -> Self;
-
fn add_summary(&mut self, summary: &Self, cx: &Self::Context);
}
@@ -138,26 +137,6 @@ where
}
}
-struct End<D>(PhantomData<D>);
-
-impl<D> End<D> {
- fn new() -> Self {
- Self(PhantomData)
- }
-}
-
-impl<'a, S: Summary, D: Dimension<'a, S>> SeekTarget<'a, S, D> for End<D> {
- fn cmp(&self, _: &D, _: &S::Context) -> Ordering {
- Ordering::Greater
- }
-}
-
-impl<D> fmt::Debug for End<D> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_tuple("End").finish()
- }
-}
-
/// Bias is used to settle ambiguities when determining positions in an ordered sequence.
///
/// The primary use case is for text, where Bias influences
@@ -372,10 +351,10 @@ impl<T: Item> SumTree<T> {
pub fn items(&self, cx: &<T::Summary as Summary>::Context) -> Vec<T> {
let mut items = Vec::new();
let mut cursor = self.cursor::<()>(cx);
- cursor.next(cx);
+ cursor.next();
while let Some(item) = cursor.item() {
items.push(item.clone());
- cursor.next(cx);
+ cursor.next();
}
items
}
@@ -384,7 +363,7 @@ impl<T: Item> SumTree<T> {
Iter::new(self)
}
- pub fn cursor<'a, S>(&'a self, cx: &<T::Summary as Summary>::Context) -> Cursor<'a, T, S>
+ pub fn cursor<'a, S>(&'a self, cx: &'a <T::Summary as Summary>::Context) -> Cursor<'a, T, S>
where
S: Dimension<'a, T::Summary>,
{
@@ -395,7 +374,7 @@ impl<T: Item> SumTree<T> {
/// that is returned cannot be used with Rust's iterators.
pub fn filter<'a, F, U>(
&'a self,
- cx: &<T::Summary as Summary>::Context,
+ cx: &'a <T::Summary as Summary>::Context,
filter_node: F,
) -> FilterCursor<'a, F, T, U>
where
@@ -525,10 +504,6 @@ impl<T: Item> SumTree<T> {
}
}
- pub fn ptr_eq(&self, other: &Self) -> bool {
- Arc::ptr_eq(&self.0, &other.0)
- }
-
fn push_tree_recursive(
&mut self,
other: SumTree<T>,
@@ -686,11 +661,6 @@ impl<T: Item> SumTree<T> {
} => child_trees.last().unwrap().rightmost_leaf(),
}
}
-
- #[cfg(debug_assertions)]
- pub fn _debug_entries(&self) -> Vec<&T> {
- self.iter().collect::<Vec<_>>()
- }
}
impl<T: Item + PartialEq> PartialEq for SumTree<T> {
@@ -710,15 +680,15 @@ impl<T: KeyedItem> SumTree<T> {
let mut replaced = None;
*self = {
let mut cursor = self.cursor::<T::Key>(cx);
- let mut new_tree = cursor.slice(&item.key(), Bias::Left, cx);
+ let mut new_tree = cursor.slice(&item.key(), Bias::Left);
if let Some(cursor_item) = cursor.item() {
if cursor_item.key() == item.key() {
replaced = Some(cursor_item.clone());
- cursor.next(cx);
+ cursor.next();
}
}
new_tree.push(item, cx);
- new_tree.append(cursor.suffix(cx), cx);
+ new_tree.append(cursor.suffix(), cx);
new_tree
};
replaced
@@ -728,14 +698,14 @@ impl<T: KeyedItem> SumTree<T> {
let mut removed = None;
*self = {
let mut cursor = self.cursor::<T::Key>(cx);
- let mut new_tree = cursor.slice(key, Bias::Left, cx);
+ let mut new_tree = cursor.slice(key, Bias::Left);
if let Some(item) = cursor.item() {
if item.key() == *key {
removed = Some(item.clone());
- cursor.next(cx);
+ cursor.next();
}
}
- new_tree.append(cursor.suffix(cx), cx);
+ new_tree.append(cursor.suffix(), cx);
new_tree
};
removed
@@ -758,7 +728,7 @@ impl<T: KeyedItem> SumTree<T> {
let mut new_tree = SumTree::new(cx);
let mut buffered_items = Vec::new();
- cursor.seek(&T::Key::zero(cx), Bias::Left, cx);
+ cursor.seek(&T::Key::zero(cx), Bias::Left);
for edit in edits {
let new_key = edit.key();
let mut old_item = cursor.item();
@@ -768,7 +738,7 @@ impl<T: KeyedItem> SumTree<T> {
.map_or(false, |old_item| old_item.key() < new_key)
{
new_tree.extend(buffered_items.drain(..), cx);
- let slice = cursor.slice(&new_key, Bias::Left, cx);
+ let slice = cursor.slice(&new_key, Bias::Left);
new_tree.append(slice, cx);
old_item = cursor.item();
}
@@ -776,7 +746,7 @@ impl<T: KeyedItem> SumTree<T> {
if let Some(old_item) = old_item {
if old_item.key() == new_key {
removed.push(old_item.clone());
- cursor.next(cx);
+ cursor.next();
}
}
@@ -789,70 +759,25 @@ impl<T: KeyedItem> SumTree<T> {
}
new_tree.extend(buffered_items, cx);
- new_tree.append(cursor.suffix(cx), cx);
+ new_tree.append(cursor.suffix(), cx);
new_tree
};
removed
}
- pub fn get(&self, key: &T::Key, cx: &<T::Summary as Summary>::Context) -> Option<&T> {
+ pub fn get<'a>(
+ &'a self,
+ key: &T::Key,
+ cx: &'a <T::Summary as Summary>::Context,
+ ) -> Option<&'a T> {
let mut cursor = self.cursor::<T::Key>(cx);
- if cursor.seek(key, Bias::Left, cx) {
+ if cursor.seek(key, Bias::Left) {
cursor.item()
} else {
None
}
}
-
- #[inline]
- pub fn contains(&self, key: &T::Key, cx: &<T::Summary as Summary>::Context) -> bool {
- self.get(key, cx).is_some()
- }
-
- pub fn update<F, R>(
- &mut self,
- key: &T::Key,
- cx: &<T::Summary as Summary>::Context,
- f: F,
- ) -> Option<R>
- where
- F: FnOnce(&mut T) -> R,
- {
- let mut cursor = self.cursor::<T::Key>(cx);
- let mut new_tree = cursor.slice(key, Bias::Left, cx);
- let mut result = None;
- if Ord::cmp(key, &cursor.end(cx)) == Ordering::Equal {
- let mut updated = cursor.item().unwrap().clone();
- result = Some(f(&mut updated));
- new_tree.push(updated, cx);
- cursor.next(cx);
- }
- new_tree.append(cursor.suffix(cx), cx);
- drop(cursor);
- *self = new_tree;
- result
- }
-
- pub fn retain<F: FnMut(&T) -> bool>(
- &mut self,
- cx: &<T::Summary as Summary>::Context,
- mut predicate: F,
- ) {
- let mut new_map = SumTree::new(cx);
-
- let mut cursor = self.cursor::<T::Key>(cx);
- cursor.next(cx);
- while let Some(item) = cursor.item() {
- if predicate(&item) {
- new_map.push(item.clone(), cx);
- }
- cursor.next(cx);
- }
- drop(cursor);
-
- *self = new_map;
- }
}
impl<T, S> Default for SumTree<T>
@@ -1061,14 +986,14 @@ mod tests {
tree = {
let mut cursor = tree.cursor::<Count>(&());
- let mut new_tree = cursor.slice(&Count(splice_start), Bias::Right, &());
+ let mut new_tree = cursor.slice(&Count(splice_start), Bias::Right);
if rng.r#gen() {
new_tree.extend(new_items, &());
} else {
new_tree.par_extend(new_items, &());
}
- cursor.seek(&Count(splice_end), Bias::Right, &());
- new_tree.append(cursor.slice(&tree_end, Bias::Right, &()), &());
+ cursor.seek(&Count(splice_end), Bias::Right);
+ new_tree.append(cursor.slice(&tree_end, Bias::Right), &());
new_tree
};
@@ -1090,10 +1015,10 @@ mod tests {
.collect::<Vec<_>>();
let mut item_ix = if rng.r#gen() {
- filter_cursor.next(&());
+ filter_cursor.next();
0
} else {
- filter_cursor.prev(&());
+ filter_cursor.prev();
expected_filtered_items.len().saturating_sub(1)
};
while item_ix < expected_filtered_items.len() {
@@ -1103,19 +1028,19 @@ mod tests {
assert_eq!(actual_item, &reference_item);
assert_eq!(filter_cursor.start().0, reference_index);
log::info!("next");
- filter_cursor.next(&());
+ filter_cursor.next();
item_ix += 1;
while item_ix > 0 && rng.gen_bool(0.2) {
log::info!("prev");
- filter_cursor.prev(&());
+ filter_cursor.prev();
item_ix -= 1;
if item_ix == 0 && rng.gen_bool(0.2) {
- filter_cursor.prev(&());
+ filter_cursor.prev();
assert_eq!(filter_cursor.item(), None);
assert_eq!(filter_cursor.start().0, 0);
- filter_cursor.next(&());
+ filter_cursor.next();
}
}
}
@@ -1124,9 +1049,9 @@ mod tests {
let mut before_start = false;
let mut cursor = tree.cursor::<Count>(&());
let start_pos = rng.gen_range(0..=reference_items.len());
- cursor.seek(&Count(start_pos), Bias::Right, &());
+ cursor.seek(&Count(start_pos), Bias::Right);
let mut pos = rng.gen_range(start_pos..=reference_items.len());
- cursor.seek_forward(&Count(pos), Bias::Right, &());
+ cursor.seek_forward(&Count(pos), Bias::Right);
for i in 0..10 {
assert_eq!(cursor.start().0, pos);
@@ -1152,13 +1077,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;
}
@@ -1174,11 +1099,11 @@ mod tests {
let end_bias = if rng.r#gen() { Bias::Left } else { Bias::Right };
let mut cursor = tree.cursor::<Count>(&());
- cursor.seek(&Count(start), start_bias, &());
- let slice = cursor.slice(&Count(end), end_bias, &());
+ cursor.seek(&Count(start), start_bias);
+ let slice = cursor.slice(&Count(end), end_bias);
- cursor.seek(&Count(start), start_bias, &());
- let summary = cursor.summary::<_, Sum>(&Count(end), end_bias, &());
+ cursor.seek(&Count(start), start_bias);
+ let summary = cursor.summary::<_, Sum>(&Count(end), end_bias);
assert_eq!(summary.0, slice.summary().sum);
}
@@ -1191,19 +1116,19 @@ mod tests {
let tree = SumTree::<u8>::default();
let mut cursor = tree.cursor::<IntegersSummary>(&());
assert_eq!(
- cursor.slice(&Count(0), Bias::Right, &()).items(&()),
+ cursor.slice(&Count(0), Bias::Right).items(&()),
Vec::<u8>::new()
);
assert_eq!(cursor.item(), None);
assert_eq!(cursor.prev_item(), None);
assert_eq!(cursor.next_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.next_item(), None);
assert_eq!(cursor.start().sum, 0);
- cursor.next(&());
+ cursor.next();
assert_eq!(cursor.item(), None);
assert_eq!(cursor.prev_item(), None);
assert_eq!(cursor.next_item(), None);
@@ -1214,7 +1139,7 @@ mod tests {
tree.extend(vec![1], &());
let mut cursor = tree.cursor::<IntegersSummary>(&());
assert_eq!(
- cursor.slice(&Count(0), Bias::Right, &()).items(&()),
+ cursor.slice(&Count(0), Bias::Right).items(&()),
Vec::<u8>::new()
);
assert_eq!(cursor.item(), Some(&1));
@@ -1222,29 +1147,29 @@ mod tests {
assert_eq!(cursor.next_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.next_item(), None);
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.next_item(), None);
assert_eq!(cursor.start().sum, 0);
let mut cursor = tree.cursor::<IntegersSummary>(&());
- assert_eq!(cursor.slice(&Count(1), Bias::Right, &()).items(&()), [1]);
+ assert_eq!(cursor.slice(&Count(1), Bias::Right).items(&()), [1]);
assert_eq!(cursor.item(), None);
assert_eq!(cursor.prev_item(), Some(&1));
assert_eq!(cursor.next_item(), None);
assert_eq!(cursor.start().sum, 1);
- cursor.seek(&Count(0), Bias::Right, &());
+ cursor.seek(&Count(0), Bias::Right);
assert_eq!(
cursor
- .slice(&tree.extent::<Count>(&()), Bias::Right, &())
+ .slice(&tree.extent::<Count>(&()), Bias::Right)
.items(&()),
[1]
);
@@ -1258,80 +1183,80 @@ mod tests {
tree.extend(vec![1, 2, 3, 4, 5, 6], &());
let mut cursor = tree.cursor::<IntegersSummary>(&());
- assert_eq!(cursor.slice(&Count(2), Bias::Right, &()).items(&()), [1, 2]);
+ assert_eq!(cursor.slice(&Count(2), Bias::Right).items(&()), [1, 2]);
assert_eq!(cursor.item(), Some(&3));
assert_eq!(cursor.prev_item(), Some(&2));
assert_eq!(cursor.next_item(), Some(&4));
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.next_item(), Some(&5));
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.next_item(), Some(&6));
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.next_item(), None);
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.next_item(), None);
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.next_item(), None);
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.next_item(), Some(&6));
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.next_item(), Some(&5));
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.next_item(), Some(&4));
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.next_item(), Some(&3));
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.next_item(), Some(&2));
assert_eq!(cursor.start().sum, 0);
- cursor.prev(&());
+ cursor.prev();
assert_eq!(cursor.item(), None);
assert_eq!(cursor.prev_item(), None);
assert_eq!(cursor.next_item(), Some(&1));
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.next_item(), Some(&2));
@@ -1340,7 +1265,7 @@ mod tests {
let mut cursor = tree.cursor::<IntegersSummary>(&());
assert_eq!(
cursor
- .slice(&tree.extent::<Count>(&()), Bias::Right, &())
+ .slice(&tree.extent::<Count>(&()), Bias::Right)
.items(&()),
tree.items(&())
);
@@ -1349,10 +1274,10 @@ mod tests {
assert_eq!(cursor.next_item(), None);
assert_eq!(cursor.start().sum, 21);
- cursor.seek(&Count(3), Bias::Right, &());
+ cursor.seek(&Count(3), Bias::Right);
assert_eq!(
cursor
- .slice(&tree.extent::<Count>(&()), Bias::Right, &())
+ .slice(&tree.extent::<Count>(&()), Bias::Right)
.items(&()),
[4, 5, 6]
);
@@ -1362,25 +1287,16 @@ mod tests {
assert_eq!(cursor.start().sum, 21);
// Seeking can bias left or right
- cursor.seek(&Count(1), Bias::Left, &());
+ cursor.seek(&Count(1), Bias::Left);
assert_eq!(cursor.item(), Some(&1));
- cursor.seek(&Count(1), Bias::Right, &());
+ cursor.seek(&Count(1), Bias::Right);
assert_eq!(cursor.item(), Some(&2));
// Slicing without resetting starts from where the cursor is parked at.
- cursor.seek(&Count(1), Bias::Right, &());
- assert_eq!(
- cursor.slice(&Count(3), Bias::Right, &()).items(&()),
- vec![2, 3]
- );
- assert_eq!(
- cursor.slice(&Count(6), Bias::Left, &()).items(&()),
- vec![4, 5]
- );
- assert_eq!(
- cursor.slice(&Count(6), Bias::Right, &()).items(&()),
- vec![6]
- );
+ cursor.seek(&Count(1), Bias::Right);
+ assert_eq!(cursor.slice(&Count(3), Bias::Right).items(&()), vec![2, 3]);
+ assert_eq!(cursor.slice(&Count(6), Bias::Left).items(&()), vec![4, 5]);
+ assert_eq!(cursor.slice(&Count(6), Bias::Right).items(&()), vec![6]);
}
#[test]
@@ -54,7 +54,7 @@ impl<K: Clone + Ord, V: Clone> TreeMap<K, V> {
pub fn get(&self, key: &K) -> Option<&V> {
let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
- cursor.seek(&MapKeyRef(Some(key)), Bias::Left, &());
+ cursor.seek(&MapKeyRef(Some(key)), Bias::Left);
if let Some(item) = cursor.item() {
if Some(key) == item.key().0.as_ref() {
Some(&item.value)
@@ -86,12 +86,12 @@ impl<K: Clone + Ord, V: Clone> TreeMap<K, V> {
let mut removed = None;
let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
let key = MapKeyRef(Some(key));
- let mut new_tree = cursor.slice(&key, Bias::Left, &());
- if key.cmp(&cursor.end(&()), &()) == Ordering::Equal {
+ let mut new_tree = cursor.slice(&key, Bias::Left);
+ if key.cmp(&cursor.end(), &()) == Ordering::Equal {
removed = Some(cursor.item().unwrap().value.clone());
- cursor.next(&());
+ cursor.next();
}
- new_tree.append(cursor.suffix(&()), &());
+ new_tree.append(cursor.suffix(), &());
drop(cursor);
self.0 = new_tree;
removed
@@ -101,9 +101,9 @@ impl<K: Clone + Ord, V: Clone> TreeMap<K, V> {
let start = MapSeekTargetAdaptor(start);
let end = MapSeekTargetAdaptor(end);
let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
- let mut new_tree = cursor.slice(&start, Bias::Left, &());
- cursor.seek(&end, Bias::Left, &());
- new_tree.append(cursor.suffix(&()), &());
+ let mut new_tree = cursor.slice(&start, Bias::Left);
+ cursor.seek(&end, Bias::Left);
+ new_tree.append(cursor.suffix(), &());
drop(cursor);
self.0 = new_tree;
}
@@ -112,15 +112,15 @@ impl<K: Clone + Ord, V: Clone> TreeMap<K, V> {
pub fn closest(&self, key: &K) -> Option<(&K, &V)> {
let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
let key = MapKeyRef(Some(key));
- cursor.seek(&key, Bias::Right, &());
- cursor.prev(&());
+ cursor.seek(&key, Bias::Right);
+ cursor.prev();
cursor.item().map(|item| (&item.key, &item.value))
}
pub fn iter_from<'a>(&'a self, from: &K) -> impl Iterator<Item = (&'a K, &'a V)> + 'a {
let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
let from_key = MapKeyRef(Some(from));
- cursor.seek(&from_key, Bias::Left, &());
+ cursor.seek(&from_key, Bias::Left);
cursor.map(|map_entry| (&map_entry.key, &map_entry.value))
}
@@ -131,15 +131,15 @@ impl<K: Clone + Ord, V: Clone> TreeMap<K, V> {
{
let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
let key = MapKeyRef(Some(key));
- let mut new_tree = cursor.slice(&key, Bias::Left, &());
+ let mut new_tree = cursor.slice(&key, Bias::Left);
let mut result = None;
- if key.cmp(&cursor.end(&()), &()) == Ordering::Equal {
+ if key.cmp(&cursor.end(), &()) == Ordering::Equal {
let mut updated = cursor.item().unwrap().clone();
result = Some(f(&mut updated.value));
new_tree.push(updated, &());
- cursor.next(&());
+ cursor.next();
}
- new_tree.append(cursor.suffix(&()), &());
+ new_tree.append(cursor.suffix(), &());
drop(cursor);
self.0 = new_tree;
result
@@ -149,12 +149,12 @@ impl<K: Clone + Ord, V: Clone> TreeMap<K, V> {
let mut new_map = SumTree::<MapEntry<K, V>>::default();
let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
- cursor.next(&());
+ cursor.next();
while let Some(item) = cursor.item() {
if predicate(&item.key, &item.value) {
new_map.push(item.clone(), &());
}
- cursor.next(&());
+ cursor.next();
}
drop(cursor);
@@ -101,7 +101,7 @@ impl Anchor {
} else {
let fragment_id = buffer.fragment_id_for_anchor(self);
let mut fragment_cursor = buffer.fragments.cursor::<(Option<&Locator>, usize)>(&None);
- fragment_cursor.seek(&Some(fragment_id), Bias::Left, &None);
+ fragment_cursor.seek(&Some(fragment_id), Bias::Left);
fragment_cursor
.item()
.map_or(false, |fragment| fragment.visible)
@@ -856,14 +856,13 @@ impl Buffer {
let mut new_ropes =
RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
let mut old_fragments = self.fragments.cursor::<FragmentTextSummary>(&None);
- let mut new_fragments =
- old_fragments.slice(&edits.peek().unwrap().0.start, Bias::Right, &None);
+ let mut new_fragments = old_fragments.slice(&edits.peek().unwrap().0.start, Bias::Right);
new_ropes.append(new_fragments.summary().text);
let mut fragment_start = old_fragments.start().visible;
for (range, new_text) in edits {
let new_text = LineEnding::normalize_arc(new_text.into());
- let fragment_end = old_fragments.end(&None).visible;
+ let fragment_end = old_fragments.end().visible;
// If the current fragment ends before this range, then jump ahead to the first fragment
// that extends past the start of this range, reusing any intervening fragments.
@@ -879,10 +878,10 @@ impl Buffer {
new_ropes.push_fragment(&suffix, suffix.visible);
new_fragments.push(suffix, &None);
}
- old_fragments.next(&None);
+ old_fragments.next();
}
- let slice = old_fragments.slice(&range.start, Bias::Right, &None);
+ let slice = old_fragments.slice(&range.start, Bias::Right);
new_ropes.append(slice.summary().text);
new_fragments.append(slice, &None);
fragment_start = old_fragments.start().visible;
@@ -935,7 +934,7 @@ impl Buffer {
// portions as deleted.
while fragment_start < range.end {
let fragment = old_fragments.item().unwrap();
- let fragment_end = old_fragments.end(&None).visible;
+ let fragment_end = old_fragments.end().visible;
let mut intersection = fragment.clone();
let intersection_end = cmp::min(range.end, fragment_end);
if fragment.visible {
@@ -962,7 +961,7 @@ impl Buffer {
fragment_start = intersection_end;
}
if fragment_end <= range.end {
- old_fragments.next(&None);
+ old_fragments.next();
}
}
@@ -974,7 +973,7 @@ impl Buffer {
// If the current fragment has been partially consumed, then consume the rest of it
// and advance to the next fragment before slicing.
if fragment_start > old_fragments.start().visible {
- let fragment_end = old_fragments.end(&None).visible;
+ let fragment_end = old_fragments.end().visible;
if fragment_end > fragment_start {
let mut suffix = old_fragments.item().unwrap().clone();
suffix.len = fragment_end - fragment_start;
@@ -983,10 +982,10 @@ impl Buffer {
new_ropes.push_fragment(&suffix, suffix.visible);
new_fragments.push(suffix, &None);
}
- old_fragments.next(&None);
+ old_fragments.next();
}
- let suffix = old_fragments.suffix(&None);
+ let suffix = old_fragments.suffix();
new_ropes.append(suffix.summary().text);
new_fragments.append(suffix, &None);
let (visible_text, deleted_text) = new_ropes.finish();
@@ -1073,16 +1072,13 @@ impl Buffer {
let mut new_ropes =
RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
let mut old_fragments = self.fragments.cursor::<(VersionedFullOffset, usize)>(&cx);
- let mut new_fragments = old_fragments.slice(
- &VersionedFullOffset::Offset(ranges[0].start),
- Bias::Left,
- &cx,
- );
+ let mut new_fragments =
+ old_fragments.slice(&VersionedFullOffset::Offset(ranges[0].start), Bias::Left);
new_ropes.append(new_fragments.summary().text);
let mut fragment_start = old_fragments.start().0.full_offset();
for (range, new_text) in edits {
- let fragment_end = old_fragments.end(&cx).0.full_offset();
+ let fragment_end = old_fragments.end().0.full_offset();
// If the current fragment ends before this range, then jump ahead to the first fragment
// that extends past the start of this range, reusing any intervening fragments.
@@ -1099,18 +1095,18 @@ impl Buffer {
new_ropes.push_fragment(&suffix, suffix.visible);
new_fragments.push(suffix, &None);
}
- old_fragments.next(&cx);
+ old_fragments.next();
}
let slice =
- old_fragments.slice(&VersionedFullOffset::Offset(range.start), Bias::Left, &cx);
+ old_fragments.slice(&VersionedFullOffset::Offset(range.start), Bias::Left);
new_ropes.append(slice.summary().text);
new_fragments.append(slice, &None);
fragment_start = old_fragments.start().0.full_offset();
}
// If we are at the end of a non-concurrent fragment, advance to the next one.
- let fragment_end = old_fragments.end(&cx).0.full_offset();
+ let fragment_end = old_fragments.end().0.full_offset();
if fragment_end == range.start && fragment_end > fragment_start {
let mut fragment = old_fragments.item().unwrap().clone();
fragment.len = fragment_end.0 - fragment_start.0;
@@ -1118,7 +1114,7 @@ impl Buffer {
new_insertions.push(InsertionFragment::insert_new(&fragment));
new_ropes.push_fragment(&fragment, fragment.visible);
new_fragments.push(fragment, &None);
- old_fragments.next(&cx);
+ old_fragments.next();
fragment_start = old_fragments.start().0.full_offset();
}
@@ -1128,7 +1124,7 @@ impl Buffer {
if fragment_start == range.start && fragment.timestamp > timestamp {
new_ropes.push_fragment(fragment, fragment.visible);
new_fragments.push(fragment.clone(), &None);
- old_fragments.next(&cx);
+ old_fragments.next();
debug_assert_eq!(fragment_start, range.start);
} else {
break;
@@ -1184,7 +1180,7 @@ impl Buffer {
// portions as deleted.
while fragment_start < range.end {
let fragment = old_fragments.item().unwrap();
- let fragment_end = old_fragments.end(&cx).0.full_offset();
+ let fragment_end = old_fragments.end().0.full_offset();
let mut intersection = fragment.clone();
let intersection_end = cmp::min(range.end, fragment_end);
if fragment.was_visible(version, &self.undo_map) {
@@ -1213,7 +1209,7 @@ impl Buffer {
fragment_start = intersection_end;
}
if fragment_end <= range.end {
- old_fragments.next(&cx);
+ old_fragments.next();
}
}
}
@@ -1221,7 +1217,7 @@ impl Buffer {
// If the current fragment has been partially consumed, then consume the rest of it
// and advance to the next fragment before slicing.
if fragment_start > old_fragments.start().0.full_offset() {
- let fragment_end = old_fragments.end(&cx).0.full_offset();
+ let fragment_end = old_fragments.end().0.full_offset();
if fragment_end > fragment_start {
let mut suffix = old_fragments.item().unwrap().clone();
suffix.len = fragment_end.0 - fragment_start.0;
@@ -1230,10 +1226,10 @@ impl Buffer {
new_ropes.push_fragment(&suffix, suffix.visible);
new_fragments.push(suffix, &None);
}
- old_fragments.next(&cx);
+ old_fragments.next();
}
- let suffix = old_fragments.suffix(&cx);
+ let suffix = old_fragments.suffix();
new_ropes.append(suffix.summary().text);
new_fragments.append(suffix, &None);
let (visible_text, deleted_text) = new_ropes.finish();
@@ -1282,7 +1278,6 @@ impl Buffer {
split_offset: insertion_slice.range.start,
},
Bias::Left,
- &(),
);
}
while let Some(item) = insertions_cursor.item() {
@@ -1292,7 +1287,7 @@ impl Buffer {
break;
}
fragment_ids.push(&item.fragment_id);
- insertions_cursor.next(&());
+ insertions_cursor.next();
}
}
fragment_ids.sort_unstable();
@@ -1309,7 +1304,7 @@ impl Buffer {
RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
for fragment_id in self.fragment_ids_for_edits(undo.counts.keys()) {
- let preceding_fragments = old_fragments.slice(&Some(fragment_id), Bias::Left, &None);
+ let preceding_fragments = old_fragments.slice(&Some(fragment_id), Bias::Left);
new_ropes.append(preceding_fragments.summary().text);
new_fragments.append(preceding_fragments, &None);
@@ -1336,11 +1331,11 @@ impl Buffer {
new_ropes.push_fragment(&fragment, fragment_was_visible);
new_fragments.push(fragment, &None);
- old_fragments.next(&None);
+ old_fragments.next();
}
}
- let suffix = old_fragments.suffix(&None);
+ let suffix = old_fragments.suffix();
new_ropes.append(suffix.summary().text);
new_fragments.append(suffix, &None);
@@ -1571,7 +1566,7 @@ impl Buffer {
.fragment_ids_for_edits(edit_ids.into_iter())
.into_iter()
.filter_map(move |fragment_id| {
- cursor.seek_forward(&Some(fragment_id), Bias::Left, &None);
+ cursor.seek_forward(&Some(fragment_id), Bias::Left);
let fragment = cursor.item()?;
let start_offset = cursor.start().1;
let end_offset = start_offset + if fragment.visible { fragment.len } else { 0 };
@@ -1793,7 +1788,7 @@ impl Buffer {
let mut cursor = self.snapshot.fragments.cursor::<Option<&Locator>>(&None);
for insertion_fragment in self.snapshot.insertions.cursor::<()>(&()) {
- cursor.seek(&Some(&insertion_fragment.fragment_id), Bias::Left, &None);
+ cursor.seek(&Some(&insertion_fragment.fragment_id), Bias::Left);
let fragment = cursor.item().unwrap();
assert_eq!(insertion_fragment.fragment_id, fragment.id);
assert_eq!(insertion_fragment.split_offset, fragment.insertion_offset);
@@ -1912,7 +1907,7 @@ impl BufferSnapshot {
.filter::<_, FragmentTextSummary>(&None, move |summary| {
!version.observed_all(&summary.max_version)
});
- cursor.next(&None);
+ cursor.next();
let mut visible_cursor = self.visible_text.cursor(0);
let mut deleted_cursor = self.deleted_text.cursor(0);
@@ -1925,18 +1920,18 @@ impl BufferSnapshot {
if fragment.was_visible(version, &self.undo_map) {
if fragment.visible {
- let text = visible_cursor.slice(cursor.end(&None).visible);
+ let text = visible_cursor.slice(cursor.end().visible);
rope.append(text);
} else {
deleted_cursor.seek_forward(cursor.start().deleted);
- let text = deleted_cursor.slice(cursor.end(&None).deleted);
+ let text = deleted_cursor.slice(cursor.end().deleted);
rope.append(text);
}
} else if fragment.visible {
- visible_cursor.seek_forward(cursor.end(&None).visible);
+ visible_cursor.seek_forward(cursor.end().visible);
}
- cursor.next(&None);
+ cursor.next();
}
if cursor.start().visible > visible_cursor.offset() {
@@ -2252,7 +2247,7 @@ impl BufferSnapshot {
timestamp: anchor.timestamp,
split_offset: anchor.offset,
};
- insertion_cursor.seek(&anchor_key, anchor.bias, &());
+ insertion_cursor.seek(&anchor_key, anchor.bias);
if let Some(insertion) = insertion_cursor.item() {
let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
if comparison == Ordering::Greater
@@ -2260,15 +2255,15 @@ impl BufferSnapshot {
&& comparison == Ordering::Equal
&& anchor.offset > 0)
{
- insertion_cursor.prev(&());
+ insertion_cursor.prev();
}
} else {
- insertion_cursor.prev(&());
+ insertion_cursor.prev();
}
let insertion = insertion_cursor.item().expect("invalid insertion");
assert_eq!(insertion.timestamp, anchor.timestamp, "invalid insertion");
- fragment_cursor.seek_forward(&Some(&insertion.fragment_id), Bias::Left, &None);
+ fragment_cursor.seek_forward(&Some(&insertion.fragment_id), Bias::Left);
let fragment = fragment_cursor.item().unwrap();
let mut fragment_offset = fragment_cursor.start().1;
if fragment.visible {
@@ -2299,7 +2294,7 @@ impl BufferSnapshot {
split_offset: anchor.offset,
};
let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>(&());
- insertion_cursor.seek(&anchor_key, anchor.bias, &());
+ insertion_cursor.seek(&anchor_key, anchor.bias);
if let Some(insertion) = insertion_cursor.item() {
let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
if comparison == Ordering::Greater
@@ -2307,10 +2302,10 @@ impl BufferSnapshot {
&& comparison == Ordering::Equal
&& anchor.offset > 0)
{
- insertion_cursor.prev(&());
+ insertion_cursor.prev();
}
} else {
- insertion_cursor.prev(&());
+ insertion_cursor.prev();
}
let Some(insertion) = insertion_cursor
@@ -2324,7 +2319,7 @@ impl BufferSnapshot {
};
let mut fragment_cursor = self.fragments.cursor::<(Option<&Locator>, usize)>(&None);
- fragment_cursor.seek(&Some(&insertion.fragment_id), Bias::Left, &None);
+ fragment_cursor.seek(&Some(&insertion.fragment_id), Bias::Left);
let fragment = fragment_cursor.item().unwrap();
let mut fragment_offset = fragment_cursor.start().1;
if fragment.visible {
@@ -2345,7 +2340,7 @@ impl BufferSnapshot {
split_offset: anchor.offset,
};
let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>(&());
- insertion_cursor.seek(&anchor_key, anchor.bias, &());
+ insertion_cursor.seek(&anchor_key, anchor.bias);
if let Some(insertion) = insertion_cursor.item() {
let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
if comparison == Ordering::Greater
@@ -2353,10 +2348,10 @@ impl BufferSnapshot {
&& comparison == Ordering::Equal
&& anchor.offset > 0)
{
- insertion_cursor.prev(&());
+ insertion_cursor.prev();
}
} else {
- insertion_cursor.prev(&());
+ insertion_cursor.prev();
}
let Some(insertion) = insertion_cursor.item().filter(|insertion| {
@@ -2395,7 +2390,7 @@ impl BufferSnapshot {
Anchor::MAX
} else {
let mut fragment_cursor = self.fragments.cursor::<usize>(&None);
- fragment_cursor.seek(&offset, bias, &None);
+ fragment_cursor.seek(&offset, bias);
let fragment = fragment_cursor.item().unwrap();
let overshoot = offset - *fragment_cursor.start();
Anchor {
@@ -2475,7 +2470,7 @@ impl BufferSnapshot {
let mut cursor = self.fragments.filter(&None, move |summary| {
!since.observed_all(&summary.max_version)
});
- cursor.next(&None);
+ cursor.next();
Some(cursor)
};
let mut cursor = self
@@ -2483,7 +2478,7 @@ impl BufferSnapshot {
.cursor::<(Option<&Locator>, FragmentTextSummary)>(&None);
let start_fragment_id = self.fragment_id_for_anchor(&range.start);
- cursor.seek(&Some(start_fragment_id), Bias::Left, &None);
+ cursor.seek(&Some(start_fragment_id), Bias::Left);
let mut visible_start = cursor.start().1.visible;
let mut deleted_start = cursor.start().1.deleted;
if let Some(fragment) = cursor.item() {
@@ -2516,7 +2511,7 @@ impl BufferSnapshot {
let mut cursor = self.fragments.filter::<_, usize>(&None, move |summary| {
!since.observed_all(&summary.max_version)
});
- cursor.next(&None);
+ cursor.next();
while let Some(fragment) = cursor.item() {
if fragment.id > *end_fragment_id {
break;
@@ -2528,7 +2523,7 @@ impl BufferSnapshot {
return true;
}
}
- cursor.next(&None);
+ cursor.next();
}
}
false
@@ -2539,14 +2534,14 @@ impl BufferSnapshot {
let mut cursor = self.fragments.filter::<_, usize>(&None, move |summary| {
!since.observed_all(&summary.max_version)
});
- cursor.next(&None);
+ cursor.next();
while let Some(fragment) = cursor.item() {
let was_visible = fragment.was_visible(since, &self.undo_map);
let is_visible = fragment.visible;
if was_visible != is_visible {
return true;
}
- cursor.next(&None);
+ cursor.next();
}
}
false
@@ -2651,7 +2646,7 @@ impl<D: TextDimension + Ord, F: FnMut(&FragmentSummary) -> bool> Iterator for Ed
while let Some(fragment) = cursor.item() {
if fragment.id < *self.range.start.0 {
- cursor.next(&None);
+ cursor.next();
continue;
} else if fragment.id > *self.range.end.0 {
break;
@@ -2684,7 +2679,7 @@ impl<D: TextDimension + Ord, F: FnMut(&FragmentSummary) -> bool> Iterator for Ed
};
if !fragment.was_visible(self.since, self.undos) && fragment.visible {
- let mut visible_end = cursor.end(&None).visible;
+ let mut visible_end = cursor.end().visible;
if fragment.id == *self.range.end.0 {
visible_end = cmp::min(
visible_end,
@@ -2710,7 +2705,7 @@ impl<D: TextDimension + Ord, F: FnMut(&FragmentSummary) -> bool> Iterator for Ed
self.new_end = new_end;
} else if fragment.was_visible(self.since, self.undos) && !fragment.visible {
- let mut deleted_end = cursor.end(&None).deleted;
+ let mut deleted_end = cursor.end().deleted;
if fragment.id == *self.range.end.0 {
deleted_end = cmp::min(
deleted_end,
@@ -2740,7 +2735,7 @@ impl<D: TextDimension + Ord, F: FnMut(&FragmentSummary) -> bool> Iterator for Ed
self.old_end = old_end;
}
- cursor.next(&None);
+ cursor.next();
}
pending_edit
@@ -74,7 +74,6 @@ impl UndoMap {
undo_id: Default::default(),
},
Bias::Left,
- &(),
);
let mut undo_count = 0;
@@ -99,7 +98,6 @@ impl UndoMap {
undo_id: Default::default(),
},
Bias::Left,
- &(),
);
let mut undo_count = 0;
@@ -2454,16 +2454,16 @@ impl Snapshot {
self.entries_by_path = {
let mut cursor = self.entries_by_path.cursor::<TraversalProgress>(&());
let mut new_entries_by_path =
- cursor.slice(&TraversalTarget::path(&removed_entry.path), Bias::Left, &());
+ cursor.slice(&TraversalTarget::path(&removed_entry.path), Bias::Left);
while let Some(entry) = cursor.item() {
if entry.path.starts_with(&removed_entry.path) {
self.entries_by_id.remove(&entry.id, &());
- cursor.next(&());
+ cursor.next();
} else {
break;
}
}
- new_entries_by_path.append(cursor.suffix(&()), &());
+ new_entries_by_path.append(cursor.suffix(), &());
new_entries_by_path
};
@@ -2576,7 +2576,6 @@ impl Snapshot {
include_ignored,
},
Bias::Right,
- &(),
);
Traversal {
snapshot: self,
@@ -2632,7 +2631,7 @@ impl Snapshot {
options: ChildEntriesOptions,
) -> ChildEntriesIter<'a> {
let mut cursor = self.entries_by_path.cursor(&());
- cursor.seek(&TraversalTarget::path(parent_path), Bias::Right, &());
+ cursor.seek(&TraversalTarget::path(parent_path), Bias::Right);
let traversal = Traversal {
snapshot: self,
cursor,
@@ -3056,9 +3055,9 @@ impl BackgroundScannerState {
.snapshot
.entries_by_path
.cursor::<TraversalProgress>(&());
- new_entries = cursor.slice(&TraversalTarget::path(path), Bias::Left, &());
- removed_entries = cursor.slice(&TraversalTarget::successor(path), Bias::Left, &());
- new_entries.append(cursor.suffix(&()), &());
+ new_entries = cursor.slice(&TraversalTarget::path(path), Bias::Left);
+ removed_entries = cursor.slice(&TraversalTarget::successor(path), Bias::Left);
+ new_entries.append(cursor.suffix(), &());
}
self.snapshot.entries_by_path = new_entries;
@@ -4925,15 +4924,15 @@ fn build_diff(
let mut old_paths = old_snapshot.entries_by_path.cursor::<PathKey>(&());
let mut new_paths = new_snapshot.entries_by_path.cursor::<PathKey>(&());
let mut last_newly_loaded_dir_path = None;
- old_paths.next(&());
- new_paths.next(&());
+ old_paths.next();
+ new_paths.next();
for path in event_paths {
let path = PathKey(path.clone());
if old_paths.item().map_or(false, |e| e.path < path.0) {
- old_paths.seek_forward(&path, Bias::Left, &());
+ old_paths.seek_forward(&path, Bias::Left);
}
if new_paths.item().map_or(false, |e| e.path < path.0) {
- new_paths.seek_forward(&path, Bias::Left, &());
+ new_paths.seek_forward(&path, Bias::Left);
}
loop {
match (old_paths.item(), new_paths.item()) {
@@ -4949,7 +4948,7 @@ fn build_diff(
match Ord::cmp(&old_entry.path, &new_entry.path) {
Ordering::Less => {
changes.push((old_entry.path.clone(), old_entry.id, Removed));
- old_paths.next(&());
+ old_paths.next();
}
Ordering::Equal => {
if phase == EventsReceivedDuringInitialScan {
@@ -4975,8 +4974,8 @@ fn build_diff(
changes.push((new_entry.path.clone(), new_entry.id, Updated));
}
}
- old_paths.next(&());
- new_paths.next(&());
+ old_paths.next();
+ new_paths.next();
}
Ordering::Greater => {
let is_newly_loaded = phase == InitialScan
@@ -4988,13 +4987,13 @@ fn build_diff(
new_entry.id,
if is_newly_loaded { Loaded } else { Added },
));
- new_paths.next(&());
+ new_paths.next();
}
}
}
(Some(old_entry), None) => {
changes.push((old_entry.path.clone(), old_entry.id, Removed));
- old_paths.next(&());
+ old_paths.next();
}
(None, Some(new_entry)) => {
let is_newly_loaded = phase == InitialScan
@@ -5006,7 +5005,7 @@ fn build_diff(
new_entry.id,
if is_newly_loaded { Loaded } else { Added },
));
- new_paths.next(&());
+ new_paths.next();
}
(None, None) => break,
}
@@ -5255,7 +5254,7 @@ impl<'a> Traversal<'a> {
start_path: &Path,
) -> Self {
let mut cursor = snapshot.entries_by_path.cursor(&());
- cursor.seek(&TraversalTarget::path(start_path), Bias::Left, &());
+ cursor.seek(&TraversalTarget::path(start_path), Bias::Left);
let mut traversal = Self {
snapshot,
cursor,
@@ -5282,14 +5281,13 @@ impl<'a> Traversal<'a> {
include_ignored: self.include_ignored,
},
Bias::Left,
- &(),
)
}
pub fn advance_to_sibling(&mut self) -> bool {
while let Some(entry) = self.cursor.item() {
self.cursor
- .seek_forward(&TraversalTarget::successor(&entry.path), Bias::Left, &());
+ .seek_forward(&TraversalTarget::successor(&entry.path), Bias::Left);
if let Some(entry) = self.cursor.item() {
if (self.include_files || !entry.is_file())
&& (self.include_dirs || !entry.is_dir())
@@ -5307,7 +5305,7 @@ impl<'a> Traversal<'a> {
return false;
};
self.cursor
- .seek(&TraversalTarget::path(parent_path), Bias::Left, &())
+ .seek(&TraversalTarget::path(parent_path), Bias::Left)
}
pub fn entry(&self) -> Option<&'a Entry> {
@@ -5326,7 +5324,7 @@ impl<'a> Traversal<'a> {
pub fn end_offset(&self) -> usize {
self.cursor
- .end(&())
+ .end()
.count(self.include_files, self.include_dirs, self.include_ignored)
}
}