1700 lines
62 KiB
Rust
1700 lines
62 KiB
Rust
use super::{
|
||
Highlights,
|
||
fold_map::{self, Chunk, FoldChunks, FoldEdit, FoldPoint, FoldSnapshot},
|
||
};
|
||
|
||
use language::Point;
|
||
use multi_buffer::MultiBufferSnapshot;
|
||
use std::{cmp, num::NonZeroU32, ops::Range};
|
||
use sum_tree::Bias;
|
||
|
||
const MAX_EXPANSION_COLUMN: u32 = 256;
|
||
|
||
// Handles a tab width <= 128
|
||
const SPACES: &[u8; rope::Chunk::MASK_BITS] = &[b' '; _];
|
||
const MAX_TABS: NonZeroU32 = NonZeroU32::new(SPACES.len() as u32).unwrap();
|
||
|
||
/// Keeps track of hard tabs in a text buffer.
|
||
///
|
||
/// See the [`display_map` module documentation](crate::display_map) for more information.
|
||
pub struct TabMap(TabSnapshot);
|
||
|
||
impl TabMap {
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn new(fold_snapshot: FoldSnapshot, tab_size: NonZeroU32) -> (Self, TabSnapshot) {
|
||
let snapshot = TabSnapshot {
|
||
fold_snapshot,
|
||
tab_size: tab_size.min(MAX_TABS),
|
||
max_expansion_column: MAX_EXPANSION_COLUMN,
|
||
version: 0,
|
||
};
|
||
(Self(snapshot.clone()), snapshot)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
pub fn set_max_expansion_column(&mut self, column: u32) -> TabSnapshot {
|
||
self.0.max_expansion_column = column;
|
||
self.0.clone()
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn sync(
|
||
&mut self,
|
||
fold_snapshot: FoldSnapshot,
|
||
mut fold_edits: Vec<FoldEdit>,
|
||
tab_size: NonZeroU32,
|
||
) -> (TabSnapshot, Vec<TabEdit>) {
|
||
let tab_size = tab_size.min(MAX_TABS);
|
||
|
||
if self.0.tab_size != tab_size {
|
||
let old_max_point = self.0.max_point();
|
||
self.0.version += 1;
|
||
self.0.fold_snapshot = fold_snapshot;
|
||
self.0.tab_size = tab_size;
|
||
return (
|
||
self.0.clone(),
|
||
vec![TabEdit {
|
||
old: TabPoint::zero()..old_max_point,
|
||
new: TabPoint::zero()..self.0.max_point(),
|
||
}],
|
||
);
|
||
}
|
||
|
||
let old_snapshot = &mut self.0;
|
||
let mut new_version = old_snapshot.version;
|
||
if old_snapshot.fold_snapshot.version != fold_snapshot.version {
|
||
new_version += 1;
|
||
}
|
||
|
||
if fold_edits.is_empty() {
|
||
old_snapshot.version = new_version;
|
||
old_snapshot.fold_snapshot = fold_snapshot;
|
||
old_snapshot.tab_size = tab_size;
|
||
return (old_snapshot.clone(), vec![]);
|
||
}
|
||
// Expand each edit to include the next tab on the same line as the edit,
|
||
// and any subsequent tabs on that line that moved across the tab expansion
|
||
// boundary.
|
||
//
|
||
// This is necessary because a tab's display width depends on its column
|
||
// position: it expands to fill up to the next tab stop. When an edit
|
||
// shifts text on a line, any tab character after the edit may now render
|
||
// at a different width even though the tab byte itself wasn't touched.
|
||
// Additionally, tabs beyond `max_expansion_column` are rendered as a
|
||
// single space instead of expanding to the next tab stop. An edit that
|
||
// shifts a tab across that boundary changes its display width, so the
|
||
// edit must cover it. We scan forward from the edit end to the end of
|
||
// the line, extending the edit to include the first subsequent tab (whose
|
||
// rendered width may have changed) and the last tab that crossed the
|
||
// expansion boundary (transitioning between expanded and non-expanded).
|
||
for fold_edit in &mut fold_edits {
|
||
let old_end = fold_edit.old.end.to_point(&old_snapshot.fold_snapshot);
|
||
let old_end_row_successor_offset = cmp::min(
|
||
FoldPoint::new(old_end.row() + 1, 0),
|
||
old_snapshot.fold_snapshot.max_point(),
|
||
)
|
||
.to_offset(&old_snapshot.fold_snapshot);
|
||
let new_end = fold_edit.new.end.to_point(&fold_snapshot);
|
||
|
||
let mut offset_from_edit = 0;
|
||
let mut first_tab_offset = None;
|
||
let mut last_tab_with_changed_expansion_offset = None;
|
||
'outer: for chunk in old_snapshot.fold_snapshot.chunks(
|
||
fold_edit.old.end..old_end_row_successor_offset,
|
||
false,
|
||
Highlights::default(),
|
||
) {
|
||
let mut remaining_tabs = chunk.tabs;
|
||
while remaining_tabs != 0 {
|
||
let ix = remaining_tabs.trailing_zeros();
|
||
let offset_from_edit = offset_from_edit + ix;
|
||
if first_tab_offset.is_none() {
|
||
first_tab_offset = Some(offset_from_edit);
|
||
}
|
||
|
||
let old_column = old_end.column() + offset_from_edit;
|
||
let new_column = new_end.column() + offset_from_edit;
|
||
let was_expanded = old_column < old_snapshot.max_expansion_column;
|
||
let is_expanded = new_column < old_snapshot.max_expansion_column;
|
||
if was_expanded != is_expanded {
|
||
last_tab_with_changed_expansion_offset = Some(offset_from_edit);
|
||
} else if !was_expanded && !is_expanded {
|
||
break 'outer;
|
||
}
|
||
|
||
remaining_tabs &= remaining_tabs - 1;
|
||
}
|
||
|
||
offset_from_edit += chunk.text.len() as u32;
|
||
if old_end.column() + offset_from_edit >= old_snapshot.max_expansion_column
|
||
&& new_end.column() + offset_from_edit >= old_snapshot.max_expansion_column
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
if let Some(offset) = last_tab_with_changed_expansion_offset.or(first_tab_offset) {
|
||
fold_edit.old.end.0 += offset as usize + 1;
|
||
fold_edit.new.end.0 += offset as usize + 1;
|
||
}
|
||
}
|
||
|
||
let new_snapshot = TabSnapshot {
|
||
fold_snapshot,
|
||
tab_size,
|
||
max_expansion_column: old_snapshot.max_expansion_column,
|
||
version: new_version,
|
||
};
|
||
|
||
let _old_alloc_ptr = fold_edits.as_ptr();
|
||
// Combine any edits that overlap due to the expansion.
|
||
let mut fold_edits = fold_edits.into_iter();
|
||
let mut first_edit = fold_edits.next().unwrap();
|
||
// This code relies on reusing allocations from the Vec<_> - at the time of writing .flatten() prevents them.
|
||
#[allow(clippy::filter_map_identity)]
|
||
let mut v: Vec<_> = fold_edits
|
||
.scan(&mut first_edit, |state, edit| {
|
||
if state.old.end >= edit.old.start {
|
||
state.old.end = edit.old.end;
|
||
state.new.end = edit.new.end;
|
||
Some(None) // Skip this edit, it's merged
|
||
} else {
|
||
let new_state = edit;
|
||
let result = Some(Some(state.clone())); // Yield the previous edit
|
||
**state = new_state;
|
||
result
|
||
}
|
||
})
|
||
.filter_map(|x| x)
|
||
.collect();
|
||
v.push(first_edit);
|
||
debug_assert_eq!(v.as_ptr(), _old_alloc_ptr, "Fold edits were reallocated");
|
||
let tab_edits = v
|
||
.into_iter()
|
||
.map(|fold_edit| {
|
||
let old_start = fold_edit.old.start.to_point(&old_snapshot.fold_snapshot);
|
||
let old_end = fold_edit.old.end.to_point(&old_snapshot.fold_snapshot);
|
||
let new_start = fold_edit.new.start.to_point(&new_snapshot.fold_snapshot);
|
||
let new_end = fold_edit.new.end.to_point(&new_snapshot.fold_snapshot);
|
||
TabEdit {
|
||
old: old_snapshot.fold_point_to_tab_point(old_start)
|
||
..old_snapshot.fold_point_to_tab_point(old_end),
|
||
new: new_snapshot.fold_point_to_tab_point(new_start)
|
||
..new_snapshot.fold_point_to_tab_point(new_end),
|
||
}
|
||
})
|
||
.collect();
|
||
*old_snapshot = new_snapshot;
|
||
(old_snapshot.clone(), tab_edits)
|
||
}
|
||
}
|
||
|
||
#[derive(Clone)]
|
||
pub struct TabSnapshot {
|
||
pub fold_snapshot: FoldSnapshot,
|
||
pub tab_size: NonZeroU32,
|
||
/// The maximum column up to which a tab can expand.
|
||
/// Any tab after this column will not expand.
|
||
pub max_expansion_column: u32,
|
||
pub version: usize,
|
||
}
|
||
|
||
impl std::ops::Deref for TabSnapshot {
|
||
type Target = FoldSnapshot;
|
||
|
||
fn deref(&self) -> &Self::Target {
|
||
&self.fold_snapshot
|
||
}
|
||
}
|
||
|
||
impl TabSnapshot {
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot {
|
||
&self.fold_snapshot.inlay_snapshot.buffer
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn line_len(&self, row: u32) -> u32 {
|
||
let max_point = self.max_point();
|
||
if row < max_point.row() {
|
||
self.fold_point_to_tab_point(FoldPoint::new(row, self.fold_snapshot.line_len(row)))
|
||
.0
|
||
.column
|
||
} else {
|
||
max_point.column()
|
||
}
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn text_summary(&self) -> TextSummary {
|
||
self.text_summary_for_range(TabPoint::zero()..self.max_point())
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all, fields(rows))]
|
||
pub fn text_summary_for_range(&self, range: Range<TabPoint>) -> TextSummary {
|
||
let input_start = self.tab_point_to_fold_point(range.start, Bias::Left).0;
|
||
let input_end = self.tab_point_to_fold_point(range.end, Bias::Right).0;
|
||
let input_summary = self
|
||
.fold_snapshot
|
||
.text_summary_for_range(input_start..input_end);
|
||
|
||
let line_end = if range.start.row() == range.end.row() {
|
||
range.end
|
||
} else {
|
||
self.max_point()
|
||
};
|
||
let first_line_chars = self
|
||
.chunks(range.start..line_end, false, Highlights::default())
|
||
.flat_map(|chunk| chunk.text.chars())
|
||
.take_while(|&c| c != '\n')
|
||
.count() as u32;
|
||
|
||
let last_line_chars = if range.start.row() == range.end.row() {
|
||
first_line_chars
|
||
} else {
|
||
self.chunks(
|
||
TabPoint::new(range.end.row(), 0)..range.end,
|
||
false,
|
||
Highlights::default(),
|
||
)
|
||
.flat_map(|chunk| chunk.text.chars())
|
||
.count() as u32
|
||
};
|
||
|
||
TextSummary {
|
||
lines: range.end.0 - range.start.0,
|
||
first_line_chars,
|
||
last_line_chars,
|
||
longest_row: input_summary.longest_row,
|
||
longest_row_chars: input_summary.longest_row_chars,
|
||
}
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub(crate) fn chunks<'a>(
|
||
&'a self,
|
||
range: Range<TabPoint>,
|
||
language_aware: bool,
|
||
highlights: Highlights<'a>,
|
||
) -> TabChunks<'a> {
|
||
let (input_start, expanded_char_column, to_next_stop) =
|
||
self.tab_point_to_fold_point(range.start, Bias::Left);
|
||
let input_column = input_start.column();
|
||
let input_start = input_start.to_offset(&self.fold_snapshot);
|
||
let input_end = self
|
||
.tab_point_to_fold_point(range.end, Bias::Right)
|
||
.0
|
||
.to_offset(&self.fold_snapshot);
|
||
let to_next_stop = if range.start.0 + Point::new(0, to_next_stop) > range.end.0 {
|
||
range.end.column() - range.start.column()
|
||
} else {
|
||
to_next_stop
|
||
};
|
||
|
||
TabChunks {
|
||
snapshot: self,
|
||
fold_chunks: self.fold_snapshot.chunks(
|
||
input_start..input_end,
|
||
language_aware,
|
||
highlights,
|
||
),
|
||
input_column,
|
||
column: expanded_char_column,
|
||
max_expansion_column: self.max_expansion_column,
|
||
output_position: range.start.0,
|
||
max_output_position: range.end.0,
|
||
tab_size: self.tab_size,
|
||
chunk: Chunk {
|
||
text: unsafe { std::str::from_utf8_unchecked(&SPACES[..to_next_stop as usize]) },
|
||
is_tab: true,
|
||
chars: 1u128.unbounded_shl(to_next_stop) - 1,
|
||
..Default::default()
|
||
},
|
||
inside_leading_tab: to_next_stop > 0,
|
||
}
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn rows(&self, row: u32) -> fold_map::FoldRows<'_> {
|
||
self.fold_snapshot.row_infos(row)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn text(&self) -> String {
|
||
self.chunks(
|
||
TabPoint::zero()..self.max_point(),
|
||
false,
|
||
Highlights::default(),
|
||
)
|
||
.map(|chunk| chunk.text)
|
||
.collect()
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn max_point(&self) -> TabPoint {
|
||
self.fold_point_to_tab_point(self.fold_snapshot.max_point())
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn clip_point(&self, point: TabPoint, bias: Bias) -> TabPoint {
|
||
self.fold_point_to_tab_point(
|
||
self.fold_snapshot
|
||
.clip_point(self.tab_point_to_fold_point(point, bias).0, bias),
|
||
)
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn fold_point_to_tab_point(&self, input: FoldPoint) -> TabPoint {
|
||
let chunks = self.fold_snapshot.chunks_at(FoldPoint::new(input.row(), 0));
|
||
let tab_cursor = TabStopCursor::new(chunks);
|
||
let expanded = self.expand_tabs(tab_cursor, input.column());
|
||
TabPoint::new(input.row(), expanded)
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn tab_point_cursor(&self) -> TabPointCursor<'_> {
|
||
TabPointCursor { this: self }
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn tab_point_to_fold_point(&self, output: TabPoint, bias: Bias) -> (FoldPoint, u32, u32) {
|
||
let chunks = self
|
||
.fold_snapshot
|
||
.chunks_at(FoldPoint::new(output.row(), 0));
|
||
|
||
let tab_cursor = TabStopCursor::new(chunks);
|
||
let expanded = output.column();
|
||
let (collapsed, expanded_char_column, to_next_stop) =
|
||
self.collapse_tabs(tab_cursor, expanded, bias);
|
||
|
||
(
|
||
FoldPoint::new(output.row(), collapsed),
|
||
expanded_char_column,
|
||
to_next_stop,
|
||
)
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn point_to_tab_point(&self, point: Point, bias: Bias) -> TabPoint {
|
||
let inlay_point = self.fold_snapshot.inlay_snapshot.to_inlay_point(point);
|
||
let fold_point = self.fold_snapshot.to_fold_point(inlay_point, bias);
|
||
self.fold_point_to_tab_point(fold_point)
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn tab_point_to_point(&self, point: TabPoint, bias: Bias) -> Point {
|
||
let fold_point = self.tab_point_to_fold_point(point, bias).0;
|
||
let inlay_point = fold_point.to_inlay_point(&self.fold_snapshot);
|
||
self.fold_snapshot
|
||
.inlay_snapshot
|
||
.to_buffer_point(inlay_point)
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
fn expand_tabs<'a>(&self, mut cursor: TabStopCursor<'a>, column: u32) -> u32 {
|
||
// we only ever act on a single row at a time
|
||
// so the main difference is that other layers build a transform sumtree, and can then just run through that
|
||
// we cant quite do this here, as we need to work with the previous layer chunk to understand the tabs of the corresponding row
|
||
// we can still do forward searches for this though, we search for a row, then traverse the column up to where we need to be
|
||
let tab_size = self.tab_size.get();
|
||
|
||
let end_column = column.min(self.max_expansion_column);
|
||
let mut seek_target = end_column;
|
||
let mut tab_count = 0;
|
||
let mut expanded_tab_len = 0;
|
||
|
||
while let Some(tab_stop) = cursor.seek_forward(seek_target) {
|
||
let expanded_chars_old = tab_stop.char_offset + expanded_tab_len - tab_count;
|
||
let tab_len = tab_size - ((expanded_chars_old - 1) % tab_size);
|
||
tab_count += 1;
|
||
expanded_tab_len += tab_len;
|
||
|
||
seek_target = end_column - cursor.byte_offset;
|
||
}
|
||
|
||
let left_over_char_bytes = if !cursor.is_char_boundary() {
|
||
cursor.bytes_until_next_char().unwrap_or(0) as u32
|
||
} else {
|
||
0
|
||
};
|
||
|
||
let collapsed_bytes = cursor.byte_offset() + left_over_char_bytes;
|
||
let expanded_bytes =
|
||
cursor.byte_offset() + expanded_tab_len - tab_count + left_over_char_bytes;
|
||
|
||
expanded_bytes + column.saturating_sub(collapsed_bytes)
|
||
}
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
fn collapse_tabs<'a>(
|
||
&self,
|
||
mut cursor: TabStopCursor<'a>,
|
||
column: u32,
|
||
bias: Bias,
|
||
) -> (u32, u32, u32) {
|
||
let tab_size = self.tab_size.get();
|
||
let mut collapsed_column = column;
|
||
let mut seek_target = column.min(self.max_expansion_column);
|
||
let mut tab_count = 0;
|
||
let mut expanded_tab_len = 0;
|
||
|
||
while let Some(tab_stop) = cursor.seek_forward(seek_target) {
|
||
// Calculate how much we want to expand this tab stop (into spaces)
|
||
let expanded_chars_old = tab_stop.char_offset + expanded_tab_len - tab_count;
|
||
let tab_len = tab_size - ((expanded_chars_old - 1) % tab_size);
|
||
// Increment tab count
|
||
tab_count += 1;
|
||
// The count of how many spaces we've added to this line in place of tab bytes
|
||
expanded_tab_len += tab_len;
|
||
|
||
// The count of bytes at this point in the iteration while considering tab_count and previous expansions
|
||
let expanded_bytes = tab_stop.byte_offset + expanded_tab_len - tab_count;
|
||
|
||
// Did we expand past the search target?
|
||
if expanded_bytes > column {
|
||
let mut expanded_chars = tab_stop.char_offset + expanded_tab_len - tab_count;
|
||
// We expanded past the search target, so need to account for the offshoot
|
||
expanded_chars -= expanded_bytes - column;
|
||
return match bias {
|
||
Bias::Left => (
|
||
cursor.byte_offset() - 1,
|
||
expanded_chars,
|
||
expanded_bytes - column,
|
||
),
|
||
Bias::Right => (cursor.byte_offset(), expanded_chars, 0),
|
||
};
|
||
} else {
|
||
// otherwise we only want to move the cursor collapse column forward
|
||
collapsed_column = collapsed_column - tab_len + 1;
|
||
seek_target = (collapsed_column - cursor.byte_offset)
|
||
.min(self.max_expansion_column - cursor.byte_offset);
|
||
}
|
||
}
|
||
|
||
let collapsed_bytes = cursor.byte_offset();
|
||
let expanded_bytes = cursor.byte_offset() + expanded_tab_len - tab_count;
|
||
let expanded_chars = cursor.char_offset() + expanded_tab_len - tab_count;
|
||
(
|
||
collapsed_bytes + column.saturating_sub(expanded_bytes),
|
||
expanded_chars,
|
||
0,
|
||
)
|
||
}
|
||
}
|
||
|
||
// todo(lw): Implement TabPointCursor properly
|
||
pub struct TabPointCursor<'this> {
|
||
this: &'this TabSnapshot,
|
||
}
|
||
|
||
impl TabPointCursor<'_> {
|
||
#[ztracing::instrument(skip_all)]
|
||
pub fn map(&mut self, point: FoldPoint) -> TabPoint {
|
||
self.this.fold_point_to_tab_point(point)
|
||
}
|
||
}
|
||
|
||
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
|
||
pub struct TabPoint(pub Point);
|
||
|
||
impl TabPoint {
|
||
pub fn new(row: u32, column: u32) -> Self {
|
||
Self(Point::new(row, column))
|
||
}
|
||
|
||
pub fn zero() -> Self {
|
||
Self::new(0, 0)
|
||
}
|
||
|
||
pub fn row(self) -> u32 {
|
||
self.0.row
|
||
}
|
||
|
||
pub fn column(self) -> u32 {
|
||
self.0.column
|
||
}
|
||
}
|
||
|
||
impl From<Point> for TabPoint {
|
||
fn from(point: Point) -> Self {
|
||
Self(point)
|
||
}
|
||
}
|
||
|
||
pub type TabEdit = text::Edit<TabPoint>;
|
||
|
||
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
||
pub struct TextSummary {
|
||
pub lines: Point,
|
||
pub first_line_chars: u32,
|
||
pub last_line_chars: u32,
|
||
pub longest_row: u32,
|
||
pub longest_row_chars: u32,
|
||
}
|
||
|
||
impl<'a> From<&'a str> for TextSummary {
|
||
#[ztracing::instrument(skip_all)]
|
||
fn from(text: &'a str) -> Self {
|
||
let sum = text::TextSummary::from(text);
|
||
|
||
TextSummary {
|
||
lines: sum.lines,
|
||
first_line_chars: sum.first_line_chars,
|
||
last_line_chars: sum.last_line_chars,
|
||
longest_row: sum.longest_row,
|
||
longest_row_chars: sum.longest_row_chars,
|
||
}
|
||
}
|
||
}
|
||
|
||
impl<'a> std::ops::AddAssign<&'a Self> for TextSummary {
|
||
#[ztracing::instrument(skip_all)]
|
||
fn add_assign(&mut self, other: &'a Self) {
|
||
let joined_chars = self.last_line_chars + other.first_line_chars;
|
||
if joined_chars > self.longest_row_chars {
|
||
self.longest_row = self.lines.row;
|
||
self.longest_row_chars = joined_chars;
|
||
}
|
||
if other.longest_row_chars > self.longest_row_chars {
|
||
self.longest_row = self.lines.row + other.longest_row;
|
||
self.longest_row_chars = other.longest_row_chars;
|
||
}
|
||
|
||
if self.lines.row == 0 {
|
||
self.first_line_chars += other.first_line_chars;
|
||
}
|
||
|
||
if other.lines.row == 0 {
|
||
self.last_line_chars += other.first_line_chars;
|
||
} else {
|
||
self.last_line_chars = other.last_line_chars;
|
||
}
|
||
|
||
self.lines += &other.lines;
|
||
}
|
||
}
|
||
|
||
pub struct TabChunks<'a> {
|
||
snapshot: &'a TabSnapshot,
|
||
max_expansion_column: u32,
|
||
max_output_position: Point,
|
||
tab_size: NonZeroU32,
|
||
// region: iteration state
|
||
fold_chunks: FoldChunks<'a>,
|
||
chunk: Chunk<'a>,
|
||
column: u32,
|
||
output_position: Point,
|
||
input_column: u32,
|
||
inside_leading_tab: bool,
|
||
// endregion: iteration state
|
||
}
|
||
|
||
impl TabChunks<'_> {
|
||
#[ztracing::instrument(skip_all)]
|
||
pub(crate) fn seek(&mut self, range: Range<TabPoint>) {
|
||
let (input_start, expanded_char_column, to_next_stop) = self
|
||
.snapshot
|
||
.tab_point_to_fold_point(range.start, Bias::Left);
|
||
let input_column = input_start.column();
|
||
let input_start = input_start.to_offset(&self.snapshot.fold_snapshot);
|
||
let input_end = self
|
||
.snapshot
|
||
.tab_point_to_fold_point(range.end, Bias::Right)
|
||
.0
|
||
.to_offset(&self.snapshot.fold_snapshot);
|
||
let to_next_stop = if range.start.0 + Point::new(0, to_next_stop) > range.end.0 {
|
||
range.end.column() - range.start.column()
|
||
} else {
|
||
to_next_stop
|
||
};
|
||
|
||
self.fold_chunks.seek(input_start..input_end);
|
||
self.input_column = input_column;
|
||
self.column = expanded_char_column;
|
||
self.output_position = range.start.0;
|
||
self.max_output_position = range.end.0;
|
||
self.chunk = Chunk {
|
||
text: unsafe { std::str::from_utf8_unchecked(&SPACES[..to_next_stop as usize]) },
|
||
is_tab: true,
|
||
chars: 1u128.unbounded_shl(to_next_stop) - 1,
|
||
..Default::default()
|
||
};
|
||
self.inside_leading_tab = to_next_stop > 0;
|
||
}
|
||
}
|
||
|
||
impl<'a> Iterator for TabChunks<'a> {
|
||
type Item = Chunk<'a>;
|
||
|
||
#[ztracing::instrument(skip_all)]
|
||
fn next(&mut self) -> Option<Self::Item> {
|
||
while self.chunk.text.is_empty() {
|
||
let chunk = self.fold_chunks.next()?;
|
||
self.chunk = chunk;
|
||
if self.inside_leading_tab {
|
||
self.chunk.text = &self.chunk.text[1..];
|
||
self.chunk.tabs >>= 1;
|
||
self.chunk.chars >>= 1;
|
||
self.chunk.newlines >>= 1;
|
||
self.inside_leading_tab = false;
|
||
self.input_column += 1;
|
||
}
|
||
}
|
||
|
||
if self.chunk.tabs & 1 != 0 {
|
||
self.chunk.text = &self.chunk.text[1..];
|
||
self.chunk.tabs >>= 1;
|
||
self.chunk.chars >>= 1;
|
||
self.chunk.newlines >>= 1;
|
||
|
||
let tab_size = if self.input_column < self.max_expansion_column {
|
||
self.tab_size.get()
|
||
} else {
|
||
1
|
||
};
|
||
let mut len = tab_size - self.column % tab_size;
|
||
let next_output_position = cmp::min(
|
||
self.output_position + Point::new(0, len),
|
||
self.max_output_position,
|
||
);
|
||
len = next_output_position.column - self.output_position.column;
|
||
self.column += len;
|
||
self.input_column += 1;
|
||
self.output_position = next_output_position;
|
||
|
||
return Some(Chunk {
|
||
text: unsafe { std::str::from_utf8_unchecked(&SPACES[..len as usize]) },
|
||
is_tab: true,
|
||
chars: 1u128.unbounded_shl(len) - 1,
|
||
tabs: 0,
|
||
newlines: 0,
|
||
..self.chunk.clone()
|
||
});
|
||
}
|
||
|
||
// Fast path: no tabs in the remaining chunk, return it directly
|
||
if self.chunk.tabs == 0 {
|
||
let chunk = self.chunk.clone();
|
||
self.chunk.text = "";
|
||
self.chunk.tabs = 0;
|
||
self.chunk.chars = 0;
|
||
self.chunk.newlines = 0;
|
||
let chunk_len = chunk.text.len() as u32;
|
||
|
||
let newline_count = chunk.newlines.count_ones();
|
||
if newline_count > 0 {
|
||
let last_newline_bit = 128 - chunk.newlines.leading_zeros();
|
||
let chars_after_last_newline =
|
||
chunk.chars.unbounded_shr(last_newline_bit).count_ones();
|
||
let bytes_after_last_newline = chunk_len - last_newline_bit;
|
||
|
||
self.column = chars_after_last_newline;
|
||
self.input_column = bytes_after_last_newline;
|
||
self.output_position = Point::new(
|
||
self.output_position.row + newline_count,
|
||
bytes_after_last_newline,
|
||
);
|
||
} else {
|
||
let char_count = chunk.chars.count_ones();
|
||
self.column += char_count;
|
||
if !self.inside_leading_tab {
|
||
self.input_column += chunk_len;
|
||
}
|
||
self.output_position.column += chunk_len;
|
||
}
|
||
|
||
return Some(chunk);
|
||
}
|
||
|
||
// Split at the next tab position
|
||
let prefix_len = self.chunk.tabs.trailing_zeros() as usize;
|
||
let (prefix, suffix) = self.chunk.text.split_at(prefix_len);
|
||
|
||
let mask = 1u128.unbounded_shl(prefix_len as u32).wrapping_sub(1);
|
||
let prefix_chars = self.chunk.chars & mask;
|
||
let prefix_newlines = self.chunk.newlines & mask;
|
||
|
||
self.chunk.text = suffix;
|
||
self.chunk.tabs = self.chunk.tabs.unbounded_shr(prefix_len as u32);
|
||
self.chunk.chars = self.chunk.chars.unbounded_shr(prefix_len as u32);
|
||
self.chunk.newlines = self.chunk.newlines.unbounded_shr(prefix_len as u32);
|
||
|
||
let newline_count = prefix_newlines.count_ones();
|
||
if newline_count > 0 {
|
||
let last_newline_bit = 128 - prefix_newlines.leading_zeros();
|
||
let chars_after_last_newline =
|
||
prefix_chars.unbounded_shr(last_newline_bit).count_ones();
|
||
let bytes_after_last_newline = prefix_len as u32 - last_newline_bit;
|
||
|
||
self.column = chars_after_last_newline;
|
||
self.input_column = bytes_after_last_newline;
|
||
self.output_position = Point::new(
|
||
self.output_position.row + newline_count,
|
||
bytes_after_last_newline,
|
||
);
|
||
} else {
|
||
let char_count = prefix_chars.count_ones();
|
||
self.column += char_count;
|
||
if !self.inside_leading_tab {
|
||
self.input_column += prefix_len as u32;
|
||
}
|
||
self.output_position.column += prefix_len as u32;
|
||
}
|
||
|
||
Some(Chunk {
|
||
text: prefix,
|
||
chars: prefix_chars,
|
||
tabs: 0,
|
||
newlines: prefix_newlines,
|
||
..self.chunk.clone()
|
||
})
|
||
}
|
||
}
|
||
|
||
struct TabStopCursor<'a> {
|
||
chunks: FoldChunks<'a>,
|
||
byte_offset: u32,
|
||
char_offset: u32,
|
||
/// Chunk
|
||
/// last tab position iterated through
|
||
current_chunk: Option<(TabStopChunk<'a>, u32)>,
|
||
}
|
||
|
||
struct TabStopChunk<'a> {
|
||
chars: u128,
|
||
text: &'a str,
|
||
tabs: u128,
|
||
}
|
||
|
||
impl<'a> TabStopCursor<'a> {
|
||
fn new(chunks: FoldChunks<'a>) -> Self {
|
||
Self {
|
||
chunks,
|
||
byte_offset: 0,
|
||
char_offset: 0,
|
||
current_chunk: None,
|
||
}
|
||
}
|
||
|
||
fn bytes_until_next_char(&self) -> Option<usize> {
|
||
self.current_chunk.as_ref().map(|&(ref chunk, idx)| {
|
||
let higher_chars = chunk.chars.unbounded_shr(idx + 1);
|
||
|
||
if higher_chars != 0 {
|
||
higher_chars.trailing_zeros() as usize + 1
|
||
} else {
|
||
chunk.text.len() - idx as usize
|
||
}
|
||
})
|
||
}
|
||
|
||
fn is_char_boundary(&self) -> bool {
|
||
self.current_chunk
|
||
.as_ref()
|
||
.is_some_and(|&(ref chunk, idx)| {
|
||
(1u128.unbounded_shl(idx) & chunk.chars) != 0 || idx as usize == chunk.text.len()
|
||
})
|
||
}
|
||
|
||
/// distance: length to move forward while searching for the next tab stop
|
||
#[ztracing::instrument(skip_all)]
|
||
fn seek_forward(&mut self, distance: u32) -> Option<TabStop> {
|
||
if distance == 0 {
|
||
return None;
|
||
}
|
||
|
||
let mut distance_remaining = distance;
|
||
|
||
while let Some((mut chunk, chunk_position)) = self.current_chunk.take().or_else(|| {
|
||
self.chunks.next().map(|chunk| {
|
||
(
|
||
TabStopChunk {
|
||
chars: chunk.chars,
|
||
text: chunk.text,
|
||
tabs: chunk.tabs,
|
||
},
|
||
0,
|
||
)
|
||
})
|
||
}) {
|
||
let chunk_len = chunk.text.len() as u32;
|
||
|
||
if chunk.tabs == 0 {
|
||
let chunk_remaining = chunk_len - chunk_position;
|
||
if chunk_remaining >= distance_remaining {
|
||
let end = chunk_position + distance_remaining;
|
||
self.byte_offset += distance_remaining;
|
||
self.char_offset +=
|
||
count_chars_in_byte_range(chunk_position..(end - 1), chunk.chars);
|
||
if end < 128 {
|
||
self.current_chunk = Some((chunk, end));
|
||
}
|
||
return None;
|
||
}
|
||
|
||
self.byte_offset += chunk_remaining;
|
||
self.char_offset +=
|
||
count_chars_in_byte_range(chunk_position..(chunk_len - 1), chunk.chars);
|
||
distance_remaining -= chunk_remaining;
|
||
continue;
|
||
}
|
||
|
||
let tab_end = chunk.tabs.trailing_zeros() + 1;
|
||
let bytes_to_tab = tab_end - chunk_position;
|
||
|
||
if bytes_to_tab > distance_remaining {
|
||
let end = chunk_position + distance_remaining;
|
||
self.byte_offset += distance_remaining;
|
||
self.char_offset +=
|
||
count_chars_in_byte_range(chunk_position..(end - 1), chunk.chars);
|
||
self.current_chunk = Some((chunk, end));
|
||
return None;
|
||
}
|
||
|
||
self.byte_offset += bytes_to_tab;
|
||
self.char_offset +=
|
||
count_chars_in_byte_range(chunk_position..(tab_end - 1), chunk.chars);
|
||
|
||
let tabstop = TabStop {
|
||
char_offset: self.char_offset,
|
||
byte_offset: self.byte_offset,
|
||
};
|
||
|
||
chunk.tabs = (chunk.tabs - 1) & chunk.tabs;
|
||
|
||
if tab_end != chunk_len {
|
||
self.current_chunk = Some((chunk, tab_end));
|
||
}
|
||
|
||
return Some(tabstop);
|
||
}
|
||
|
||
None
|
||
}
|
||
|
||
fn byte_offset(&self) -> u32 {
|
||
self.byte_offset
|
||
}
|
||
|
||
fn char_offset(&self) -> u32 {
|
||
self.char_offset
|
||
}
|
||
}
|
||
|
||
#[inline(always)]
|
||
fn count_chars_in_byte_range(range: Range<u32>, bitmap: u128) -> u32 {
|
||
let low_mask = u128::MAX << range.start;
|
||
let high_mask = u128::MAX >> (127 - range.end);
|
||
(bitmap & low_mask & high_mask).count_ones()
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
struct TabStop {
|
||
char_offset: u32,
|
||
byte_offset: u32,
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use std::mem;
|
||
|
||
use super::*;
|
||
use crate::{
|
||
MultiBuffer,
|
||
display_map::{
|
||
fold_map::{FoldMap, FoldOffset, FoldPlaceholder},
|
||
inlay_map::InlayMap,
|
||
},
|
||
};
|
||
use multi_buffer::MultiBufferOffset;
|
||
use rand::{Rng, prelude::StdRng};
|
||
use util;
|
||
|
||
impl TabSnapshot {
|
||
fn expected_collapse_tabs(
|
||
&self,
|
||
chars: impl Iterator<Item = char>,
|
||
column: u32,
|
||
bias: Bias,
|
||
) -> (u32, u32, u32) {
|
||
let tab_size = self.tab_size.get();
|
||
|
||
let mut expanded_bytes = 0;
|
||
let mut expanded_chars = 0;
|
||
let mut collapsed_bytes = 0;
|
||
for c in chars {
|
||
if expanded_bytes >= column {
|
||
break;
|
||
}
|
||
if collapsed_bytes >= self.max_expansion_column {
|
||
break;
|
||
}
|
||
|
||
if c == '\t' {
|
||
let tab_len = tab_size - (expanded_chars % tab_size);
|
||
expanded_chars += tab_len;
|
||
expanded_bytes += tab_len;
|
||
if expanded_bytes > column {
|
||
expanded_chars -= expanded_bytes - column;
|
||
return match bias {
|
||
Bias::Left => {
|
||
(collapsed_bytes, expanded_chars, expanded_bytes - column)
|
||
}
|
||
Bias::Right => (collapsed_bytes + 1, expanded_chars, 0),
|
||
};
|
||
}
|
||
} else {
|
||
expanded_chars += 1;
|
||
expanded_bytes += c.len_utf8() as u32;
|
||
}
|
||
|
||
if expanded_bytes > column && matches!(bias, Bias::Left) {
|
||
expanded_chars -= 1;
|
||
break;
|
||
}
|
||
|
||
collapsed_bytes += c.len_utf8() as u32;
|
||
}
|
||
|
||
(
|
||
collapsed_bytes + column.saturating_sub(expanded_bytes),
|
||
expanded_chars,
|
||
0,
|
||
)
|
||
}
|
||
|
||
pub fn expected_to_tab_point(&self, input: FoldPoint) -> TabPoint {
|
||
let chars = self.fold_snapshot.chars_at(FoldPoint::new(input.row(), 0));
|
||
let expanded = self.expected_expand_tabs(chars, input.column());
|
||
TabPoint::new(input.row(), expanded)
|
||
}
|
||
|
||
fn expected_expand_tabs(&self, chars: impl Iterator<Item = char>, column: u32) -> u32 {
|
||
let tab_size = self.tab_size.get();
|
||
|
||
let mut expanded_chars = 0;
|
||
let mut expanded_bytes = 0;
|
||
let mut collapsed_bytes = 0;
|
||
let end_column = column.min(self.max_expansion_column);
|
||
for c in chars {
|
||
if collapsed_bytes >= end_column {
|
||
break;
|
||
}
|
||
if c == '\t' {
|
||
let tab_len = tab_size - expanded_chars % tab_size;
|
||
expanded_bytes += tab_len;
|
||
expanded_chars += tab_len;
|
||
} else {
|
||
expanded_bytes += c.len_utf8() as u32;
|
||
expanded_chars += 1;
|
||
}
|
||
collapsed_bytes += c.len_utf8() as u32;
|
||
}
|
||
|
||
expanded_bytes + column.saturating_sub(collapsed_bytes)
|
||
}
|
||
|
||
fn expected_to_fold_point(&self, output: TabPoint, bias: Bias) -> (FoldPoint, u32, u32) {
|
||
let chars = self.fold_snapshot.chars_at(FoldPoint::new(output.row(), 0));
|
||
let expanded = output.column();
|
||
let (collapsed, expanded_char_column, to_next_stop) =
|
||
self.expected_collapse_tabs(chars, expanded, bias);
|
||
(
|
||
FoldPoint::new(output.row(), collapsed),
|
||
expanded_char_column,
|
||
to_next_stop,
|
||
)
|
||
}
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_expand_tabs(cx: &mut gpui::App) {
|
||
let input = "A\tBC\tDEF\tG\tHI\tJ\tK\tL\tM";
|
||
|
||
let buffer = MultiBuffer::build_simple(input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
|
||
|
||
for (ix, _) in input.char_indices() {
|
||
let fold_point = FoldPoint::new(0, ix as u32);
|
||
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_tab_point(fold_point),
|
||
tab_snapshot.fold_point_to_tab_point(fold_point),
|
||
"Failed with fold_point at column {ix}"
|
||
);
|
||
}
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_collapse_tabs(cx: &mut gpui::App) {
|
||
let input = "A\tBC\tDEF\tG\tHI\tJ\tK\tL\tM";
|
||
|
||
let buffer = MultiBuffer::build_simple(input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
|
||
|
||
for (ix, _) in input.char_indices() {
|
||
let range = TabPoint::new(0, ix as u32)..tab_snapshot.max_point();
|
||
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_fold_point(range.start, Bias::Left),
|
||
tab_snapshot.tab_point_to_fold_point(range.start, Bias::Left),
|
||
"Failed with tab_point at column {ix}"
|
||
);
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_fold_point(range.start, Bias::Right),
|
||
tab_snapshot.tab_point_to_fold_point(range.start, Bias::Right),
|
||
"Failed with tab_point at column {ix}"
|
||
);
|
||
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_fold_point(range.end, Bias::Left),
|
||
tab_snapshot.tab_point_to_fold_point(range.end, Bias::Left),
|
||
"Failed with tab_point at column {ix}"
|
||
);
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_fold_point(range.end, Bias::Right),
|
||
tab_snapshot.tab_point_to_fold_point(range.end, Bias::Right),
|
||
"Failed with tab_point at column {ix}"
|
||
);
|
||
}
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_to_fold_point_panic_reproduction(cx: &mut gpui::App) {
|
||
// This test reproduces a specific panic where to_fold_point returns incorrect results
|
||
let _text = "use macro_rules_attribute::apply;\nuse serde_json::Value;\nuse smol::{\n io::AsyncReadExt,\n process::{Command, Stdio},\n};\nuse smol_macros::main;\nuse std::io;\n\nfn test_random() {\n // Generate a random value\n let random_value = std::time::SystemTime::now()\n .duration_since(std::time::UNIX_EPOCH)\n .unwrap()\n .as_secs()\n % 100;\n\n // Create some complex nested data structures\n let mut vector = Vec::new();\n for i in 0..random_value {\n vector.push(i);\n }\n ";
|
||
|
||
let text = "γ\tw⭐\n🍐🍗 \t";
|
||
let buffer = MultiBuffer::build_simple(text, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
|
||
|
||
// This should panic with the expected vs actual mismatch
|
||
let tab_point = TabPoint::new(0, 9);
|
||
let result = tab_snapshot.tab_point_to_fold_point(tab_point, Bias::Left);
|
||
let expected = tab_snapshot.expected_to_fold_point(tab_point, Bias::Left);
|
||
|
||
assert_eq!(result, expected);
|
||
}
|
||
|
||
#[gpui::test(iterations = 100)]
|
||
fn test_collapse_tabs_random(cx: &mut gpui::App, mut rng: StdRng) {
|
||
// Generate random input string with up to 200 characters including tabs
|
||
// to stay within the MAX_EXPANSION_COLUMN limit of 256
|
||
let len = rng.random_range(0..=2048);
|
||
let tab_size = NonZeroU32::new(rng.random_range(1..=4)).unwrap();
|
||
let mut input = String::with_capacity(len);
|
||
|
||
for _ in 0..len {
|
||
if rng.random_bool(0.1) {
|
||
// 10% chance of inserting a tab
|
||
input.push('\t');
|
||
} else {
|
||
// 90% chance of inserting a random ASCII character (excluding tab, newline, carriage return)
|
||
let ch = loop {
|
||
let ascii_code = rng.random_range(32..=126); // printable ASCII range
|
||
let ch = ascii_code as u8 as char;
|
||
if ch != '\t' {
|
||
break ch;
|
||
}
|
||
};
|
||
input.push(ch);
|
||
}
|
||
}
|
||
|
||
let buffer = MultiBuffer::build_simple(&input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let (_, mut tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
|
||
tab_snapshot.max_expansion_column = rng.random_range(0..323);
|
||
tab_snapshot.tab_size = tab_size;
|
||
|
||
for (ix, _) in input.char_indices() {
|
||
let range = TabPoint::new(0, ix as u32)..tab_snapshot.max_point();
|
||
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_fold_point(range.start, Bias::Left),
|
||
tab_snapshot.tab_point_to_fold_point(range.start, Bias::Left),
|
||
"Failed with input: {}, with idx: {ix}",
|
||
input
|
||
);
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_fold_point(range.start, Bias::Right),
|
||
tab_snapshot.tab_point_to_fold_point(range.start, Bias::Right),
|
||
"Failed with input: {}, with idx: {ix}",
|
||
input
|
||
);
|
||
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_fold_point(range.end, Bias::Left),
|
||
tab_snapshot.tab_point_to_fold_point(range.end, Bias::Left),
|
||
"Failed with input: {}, with idx: {ix}",
|
||
input
|
||
);
|
||
assert_eq!(
|
||
tab_snapshot.expected_to_fold_point(range.end, Bias::Right),
|
||
tab_snapshot.tab_point_to_fold_point(range.end, Bias::Right),
|
||
"Failed with input: {}, with idx: {ix}",
|
||
input
|
||
);
|
||
}
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_long_lines(cx: &mut gpui::App) {
|
||
let max_expansion_column = 12;
|
||
let input = "A\tBC\tDEF\tG\tHI\tJ\tK\tL\tM";
|
||
let output = "A BC DEF G HI J K L M";
|
||
|
||
let buffer = MultiBuffer::build_simple(input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let (_, mut tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
|
||
|
||
tab_snapshot.max_expansion_column = max_expansion_column;
|
||
assert_eq!(tab_snapshot.text(), output);
|
||
|
||
for (ix, c) in input.char_indices() {
|
||
assert_eq!(
|
||
tab_snapshot
|
||
.chunks(
|
||
TabPoint::new(0, ix as u32)..tab_snapshot.max_point(),
|
||
false,
|
||
Highlights::default(),
|
||
)
|
||
.map(|c| c.text)
|
||
.collect::<String>(),
|
||
&output[ix..],
|
||
"text from index {ix}"
|
||
);
|
||
|
||
if c != '\t' {
|
||
let input_point = Point::new(0, ix as u32);
|
||
let output_point = Point::new(0, output.find(c).unwrap() as u32);
|
||
assert_eq!(
|
||
tab_snapshot.fold_point_to_tab_point(FoldPoint(input_point)),
|
||
TabPoint(output_point),
|
||
"to_tab_point({input_point:?})"
|
||
);
|
||
assert_eq!(
|
||
tab_snapshot
|
||
.tab_point_to_fold_point(TabPoint(output_point), Bias::Left)
|
||
.0,
|
||
FoldPoint(input_point),
|
||
"to_fold_point({output_point:?})"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_long_lines_with_character_spanning_max_expansion_column(cx: &mut gpui::App) {
|
||
let max_expansion_column = 8;
|
||
let input = "abcdefg⋯hij";
|
||
|
||
let buffer = MultiBuffer::build_simple(input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let (_, mut tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
|
||
|
||
tab_snapshot.max_expansion_column = max_expansion_column;
|
||
assert_eq!(tab_snapshot.text(), input);
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_marking_tabs(cx: &mut gpui::App) {
|
||
let input = "\t \thello";
|
||
|
||
let buffer = MultiBuffer::build_simple(input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
|
||
|
||
assert_eq!(
|
||
chunks(&tab_snapshot, TabPoint::zero()),
|
||
vec![
|
||
(" ".to_string(), true),
|
||
(" ".to_string(), false),
|
||
(" ".to_string(), true),
|
||
("hello".to_string(), false),
|
||
]
|
||
);
|
||
assert_eq!(
|
||
chunks(&tab_snapshot, TabPoint::new(0, 2)),
|
||
vec![
|
||
(" ".to_string(), true),
|
||
(" ".to_string(), false),
|
||
(" ".to_string(), true),
|
||
("hello".to_string(), false),
|
||
]
|
||
);
|
||
|
||
fn chunks(snapshot: &TabSnapshot, start: TabPoint) -> Vec<(String, bool)> {
|
||
let mut chunks = Vec::new();
|
||
let mut was_tab = false;
|
||
let mut text = String::new();
|
||
for chunk in snapshot.chunks(start..snapshot.max_point(), false, Highlights::default())
|
||
{
|
||
if chunk.is_tab != was_tab {
|
||
if !text.is_empty() {
|
||
chunks.push((mem::take(&mut text), was_tab));
|
||
}
|
||
was_tab = chunk.is_tab;
|
||
}
|
||
text.push_str(chunk.text);
|
||
}
|
||
|
||
if !text.is_empty() {
|
||
chunks.push((text, was_tab));
|
||
}
|
||
chunks
|
||
}
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_empty_chunk_after_leading_tab_trim(cx: &mut gpui::App) {
|
||
// We fold "hello" (offsets 1..6) so the fold map creates a
|
||
// transform boundary at offset 1, producing a 1-byte fold chunk
|
||
// for the tab.
|
||
let text = "\thello";
|
||
let buffer = MultiBuffer::build_simple(text, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let mut fold_map = FoldMap::new(inlay_snapshot.clone()).0;
|
||
|
||
let (mut writer, _, _) = fold_map.write(inlay_snapshot.clone(), vec![]);
|
||
writer.fold(vec![(
|
||
MultiBufferOffset(1)..MultiBufferOffset(6),
|
||
FoldPlaceholder::test(),
|
||
)]);
|
||
let (fold_snapshot, _) = fold_map.read(inlay_snapshot, vec![]);
|
||
|
||
let tab_size = NonZeroU32::new(4).unwrap();
|
||
let (_, tab_snapshot) = TabMap::new(fold_snapshot, tab_size);
|
||
|
||
// The tab at column 0 expands to 4 spaces (columns 0‥4).
|
||
// Seek starting at column 2 (middle of that tab) so that
|
||
// `inside_leading_tab = true` and `to_next_stop = 2`.
|
||
// Set the end just past the tab expansion so the iterator must
|
||
// process the tab byte from the fold chunk.
|
||
let max = tab_snapshot.max_point();
|
||
let start = TabPoint::new(0, 2);
|
||
let end = max;
|
||
|
||
// This should not panic.
|
||
let result: String = tab_snapshot
|
||
.chunks(start..end, false, Highlights::default())
|
||
.map(|c| c.text)
|
||
.collect();
|
||
assert!(!result.is_empty());
|
||
}
|
||
|
||
#[gpui::test(iterations = 100)]
|
||
fn test_random_tabs(cx: &mut gpui::App, mut rng: StdRng) {
|
||
let tab_size = NonZeroU32::new(rng.random_range(1..=4)).unwrap();
|
||
let len = rng.random_range(0..30);
|
||
let buffer = if rng.random() {
|
||
let text = util::RandomCharIter::new(&mut rng)
|
||
.take(len)
|
||
.collect::<String>();
|
||
MultiBuffer::build_simple(&text, cx)
|
||
} else {
|
||
MultiBuffer::build_random(&mut rng, cx)
|
||
};
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
log::info!("Buffer text: {:?}", buffer_snapshot.text());
|
||
|
||
let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
log::info!("InlayMap text: {:?}", inlay_snapshot.text());
|
||
let (mut fold_map, _) = FoldMap::new(inlay_snapshot.clone());
|
||
fold_map.randomly_mutate(&mut rng);
|
||
let (fold_snapshot, _) = fold_map.read(inlay_snapshot, vec![]);
|
||
log::info!("FoldMap text: {:?}", fold_snapshot.text());
|
||
let (inlay_snapshot, _) = inlay_map.randomly_mutate(&mut 0, &mut rng);
|
||
log::info!("InlayMap text: {:?}", inlay_snapshot.text());
|
||
|
||
let (mut tab_map, _) = TabMap::new(fold_snapshot, tab_size);
|
||
let tabs_snapshot = tab_map.set_max_expansion_column(32);
|
||
|
||
let text = text::Rope::from(tabs_snapshot.text().as_str());
|
||
log::info!(
|
||
"TabMap text (tab size: {}): {:?}",
|
||
tab_size,
|
||
tabs_snapshot.text(),
|
||
);
|
||
|
||
for _ in 0..5 {
|
||
let end_row = rng.random_range(0..=text.max_point().row);
|
||
let end_column = rng.random_range(0..=text.line_len(end_row));
|
||
let mut end = TabPoint(text.clip_point(Point::new(end_row, end_column), Bias::Right));
|
||
let start_row = rng.random_range(0..=text.max_point().row);
|
||
let start_column = rng.random_range(0..=text.line_len(start_row));
|
||
let mut start =
|
||
TabPoint(text.clip_point(Point::new(start_row, start_column), Bias::Left));
|
||
if start > end {
|
||
mem::swap(&mut start, &mut end);
|
||
}
|
||
|
||
let expected_text = text
|
||
.chunks_in_range(text.point_to_offset(start.0)..text.point_to_offset(end.0))
|
||
.collect::<String>();
|
||
let expected_summary = TextSummary::from(expected_text.as_str());
|
||
assert_eq!(
|
||
tabs_snapshot
|
||
.chunks(start..end, false, Highlights::default())
|
||
.map(|c| c.text)
|
||
.collect::<String>(),
|
||
expected_text,
|
||
"chunks({:?}..{:?})",
|
||
start,
|
||
end
|
||
);
|
||
|
||
let mut actual_summary = tabs_snapshot.text_summary_for_range(start..end);
|
||
if tab_size.get() > 1 && inlay_snapshot.text().contains('\t') {
|
||
actual_summary.longest_row = expected_summary.longest_row;
|
||
actual_summary.longest_row_chars = expected_summary.longest_row_chars;
|
||
}
|
||
assert_eq!(actual_summary, expected_summary);
|
||
}
|
||
|
||
for row in 0..=text.max_point().row {
|
||
assert_eq!(
|
||
tabs_snapshot.line_len(row),
|
||
text.line_len(row),
|
||
"line_len({row})"
|
||
);
|
||
}
|
||
}
|
||
|
||
#[gpui::test(iterations = 100)]
|
||
fn test_to_tab_point_random(cx: &mut gpui::App, mut rng: StdRng) {
|
||
let tab_size = NonZeroU32::new(rng.random_range(1..=16)).unwrap();
|
||
let len = rng.random_range(0..=2000);
|
||
|
||
// Generate random text using RandomCharIter
|
||
let text = util::RandomCharIter::new(&mut rng)
|
||
.take(len)
|
||
.collect::<String>();
|
||
|
||
// Create buffer and tab map
|
||
let buffer = MultiBuffer::build_simple(&text, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let (mut tab_map, _) = TabMap::new(fold_snapshot, tab_size);
|
||
|
||
let mut next_inlay_id = 0;
|
||
let (inlay_snapshot, inlay_edits) = inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng);
|
||
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
|
||
let max_fold_point = fold_snapshot.max_point();
|
||
let (mut tab_snapshot, _) = tab_map.sync(fold_snapshot.clone(), fold_edits, tab_size);
|
||
|
||
// Test random fold points
|
||
for _ in 0..50 {
|
||
tab_snapshot.max_expansion_column = rng.random_range(0..=256);
|
||
// Generate random fold point
|
||
let row = rng.random_range(0..=max_fold_point.row());
|
||
let max_column = if row < max_fold_point.row() {
|
||
fold_snapshot.line_len(row)
|
||
} else {
|
||
max_fold_point.column()
|
||
};
|
||
let column = rng.random_range(0..=max_column + 10);
|
||
let fold_point = FoldPoint::new(row, column);
|
||
|
||
let actual = tab_snapshot.fold_point_to_tab_point(fold_point);
|
||
let expected = tab_snapshot.expected_to_tab_point(fold_point);
|
||
|
||
assert_eq!(
|
||
actual, expected,
|
||
"to_tab_point mismatch for fold_point {:?} in text {:?}",
|
||
fold_point, text
|
||
);
|
||
}
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_tab_stop_cursor_utf8(cx: &mut gpui::App) {
|
||
let text = "\tfoo\tbarbarbar\t\tbaz\n";
|
||
let buffer = MultiBuffer::build_simple(text, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let chunks = fold_snapshot.chunks(
|
||
FoldOffset(MultiBufferOffset(0))..fold_snapshot.len(),
|
||
false,
|
||
Default::default(),
|
||
);
|
||
let mut cursor = TabStopCursor::new(chunks);
|
||
assert!(cursor.seek_forward(0).is_none());
|
||
let mut tab_stops = Vec::new();
|
||
|
||
let mut all_tab_stops = Vec::new();
|
||
let mut byte_offset = 0;
|
||
for (offset, ch) in buffer.read(cx).snapshot(cx).text().char_indices() {
|
||
byte_offset += ch.len_utf8() as u32;
|
||
|
||
if ch == '\t' {
|
||
all_tab_stops.push(TabStop {
|
||
byte_offset,
|
||
char_offset: offset as u32 + 1,
|
||
});
|
||
}
|
||
}
|
||
|
||
while let Some(tab_stop) = cursor.seek_forward(u32::MAX) {
|
||
tab_stops.push(tab_stop);
|
||
}
|
||
pretty_assertions::assert_eq!(tab_stops.as_slice(), all_tab_stops.as_slice(),);
|
||
|
||
assert_eq!(cursor.byte_offset(), byte_offset);
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_tab_stop_with_end_range_utf8(cx: &mut gpui::App) {
|
||
let input = "A\tBC\t"; // DEF\tG\tHI\tJ\tK\tL\tM
|
||
|
||
let buffer = MultiBuffer::build_simple(input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
|
||
let chunks = fold_snapshot.chunks_at(FoldPoint::new(0, 0));
|
||
let mut cursor = TabStopCursor::new(chunks);
|
||
|
||
let mut actual_tab_stops = Vec::new();
|
||
|
||
let mut expected_tab_stops = Vec::new();
|
||
let mut byte_offset = 0;
|
||
for (offset, ch) in buffer.read(cx).snapshot(cx).text().char_indices() {
|
||
byte_offset += ch.len_utf8() as u32;
|
||
|
||
if ch == '\t' {
|
||
expected_tab_stops.push(TabStop {
|
||
byte_offset,
|
||
char_offset: offset as u32 + 1,
|
||
});
|
||
}
|
||
}
|
||
|
||
while let Some(tab_stop) = cursor.seek_forward(u32::MAX) {
|
||
actual_tab_stops.push(tab_stop);
|
||
}
|
||
pretty_assertions::assert_eq!(actual_tab_stops.as_slice(), expected_tab_stops.as_slice(),);
|
||
|
||
assert_eq!(cursor.byte_offset(), byte_offset);
|
||
}
|
||
|
||
#[gpui::test(iterations = 100)]
|
||
fn test_tab_stop_cursor_random_utf8(cx: &mut gpui::App, mut rng: StdRng) {
|
||
// Generate random input string with up to 512 characters including tabs
|
||
let len = rng.random_range(0..=2048);
|
||
let mut input = String::with_capacity(len);
|
||
|
||
let mut skip_tabs = rng.random_bool(0.10);
|
||
for idx in 0..len {
|
||
if idx % 128 == 0 {
|
||
skip_tabs = rng.random_bool(0.10);
|
||
}
|
||
|
||
if rng.random_bool(0.15) && !skip_tabs {
|
||
input.push('\t');
|
||
} else {
|
||
let ch = loop {
|
||
let ascii_code = rng.random_range(32..=126); // printable ASCII range
|
||
let ch = ascii_code as u8 as char;
|
||
if ch != '\t' {
|
||
break ch;
|
||
}
|
||
};
|
||
input.push(ch);
|
||
}
|
||
}
|
||
|
||
// Build the buffer and create cursor
|
||
let buffer = MultiBuffer::build_simple(&input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
|
||
// First, collect all expected tab positions
|
||
let mut all_tab_stops = Vec::new();
|
||
let mut byte_offset = 1;
|
||
let mut char_offset = 1;
|
||
for ch in buffer_snapshot.text().chars() {
|
||
if ch == '\t' {
|
||
all_tab_stops.push(TabStop {
|
||
byte_offset,
|
||
char_offset,
|
||
});
|
||
}
|
||
byte_offset += ch.len_utf8() as u32;
|
||
char_offset += 1;
|
||
}
|
||
|
||
// Test with various distances
|
||
let distances = vec![1, 5, 10, 50, 100, u32::MAX];
|
||
// let distances = vec![150];
|
||
|
||
for distance in distances {
|
||
let chunks = fold_snapshot.chunks_at(FoldPoint::new(0, 0));
|
||
let mut cursor = TabStopCursor::new(chunks);
|
||
|
||
let mut found_tab_stops = Vec::new();
|
||
let mut position = distance;
|
||
while let Some(tab_stop) = cursor.seek_forward(position) {
|
||
found_tab_stops.push(tab_stop);
|
||
position = distance - tab_stop.byte_offset;
|
||
}
|
||
|
||
let expected_found_tab_stops: Vec<_> = all_tab_stops
|
||
.iter()
|
||
.take_while(|tab_stop| tab_stop.byte_offset <= distance)
|
||
.cloned()
|
||
.collect();
|
||
|
||
pretty_assertions::assert_eq!(
|
||
found_tab_stops,
|
||
expected_found_tab_stops,
|
||
"TabStopCursor output mismatch for distance {}. Input: {:?}",
|
||
distance,
|
||
input
|
||
);
|
||
|
||
let final_position = cursor.byte_offset();
|
||
if !found_tab_stops.is_empty() {
|
||
let last_tab_stop = found_tab_stops.last().unwrap();
|
||
assert!(
|
||
final_position >= last_tab_stop.byte_offset,
|
||
"Cursor final position {} is before last tab stop {}. Input: {:?}",
|
||
final_position,
|
||
last_tab_stop.byte_offset,
|
||
input
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[gpui::test]
|
||
fn test_tab_stop_cursor_utf16(cx: &mut gpui::App) {
|
||
let text = "\r\t😁foo\tb😀arbar🤯bar\t\tbaz\n";
|
||
let buffer = MultiBuffer::build_simple(text, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
let chunks = fold_snapshot.chunks(
|
||
FoldOffset(MultiBufferOffset(0))..fold_snapshot.len(),
|
||
false,
|
||
Default::default(),
|
||
);
|
||
let mut cursor = TabStopCursor::new(chunks);
|
||
assert!(cursor.seek_forward(0).is_none());
|
||
|
||
let mut expected_tab_stops = Vec::new();
|
||
let mut byte_offset = 0;
|
||
for (i, ch) in fold_snapshot.chars_at(FoldPoint::new(0, 0)).enumerate() {
|
||
byte_offset += ch.len_utf8() as u32;
|
||
|
||
if ch == '\t' {
|
||
expected_tab_stops.push(TabStop {
|
||
byte_offset,
|
||
char_offset: i as u32 + 1,
|
||
});
|
||
}
|
||
}
|
||
|
||
let mut actual_tab_stops = Vec::new();
|
||
while let Some(tab_stop) = cursor.seek_forward(u32::MAX) {
|
||
actual_tab_stops.push(tab_stop);
|
||
}
|
||
|
||
pretty_assertions::assert_eq!(actual_tab_stops.as_slice(), expected_tab_stops.as_slice(),);
|
||
|
||
assert_eq!(cursor.byte_offset(), byte_offset);
|
||
}
|
||
|
||
#[gpui::test(iterations = 100)]
|
||
fn test_tab_stop_cursor_random_utf16(cx: &mut gpui::App, mut rng: StdRng) {
|
||
// Generate random input string with up to 512 characters including tabs
|
||
let len = rng.random_range(0..=2048);
|
||
let input = util::RandomCharIter::new(&mut rng)
|
||
.take(len)
|
||
.collect::<String>();
|
||
|
||
// Build the buffer and create cursor
|
||
let buffer = MultiBuffer::build_simple(&input, cx);
|
||
let buffer_snapshot = buffer.read(cx).snapshot(cx);
|
||
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
|
||
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
|
||
|
||
// First, collect all expected tab positions
|
||
let mut all_tab_stops = Vec::new();
|
||
let mut byte_offset = 0;
|
||
for (i, ch) in buffer_snapshot.text().chars().enumerate() {
|
||
byte_offset += ch.len_utf8() as u32;
|
||
if ch == '\t' {
|
||
all_tab_stops.push(TabStop {
|
||
byte_offset,
|
||
char_offset: i as u32 + 1,
|
||
});
|
||
}
|
||
}
|
||
|
||
// Test with various distances
|
||
// let distances = vec![1, 5, 10, 50, 100, u32::MAX];
|
||
let distances = vec![150];
|
||
|
||
for distance in distances {
|
||
let chunks = fold_snapshot.chunks_at(FoldPoint::new(0, 0));
|
||
let mut cursor = TabStopCursor::new(chunks);
|
||
|
||
let mut found_tab_stops = Vec::new();
|
||
let mut position = distance;
|
||
while let Some(tab_stop) = cursor.seek_forward(position) {
|
||
found_tab_stops.push(tab_stop);
|
||
position = distance - tab_stop.byte_offset;
|
||
}
|
||
|
||
let expected_found_tab_stops: Vec<_> = all_tab_stops
|
||
.iter()
|
||
.take_while(|tab_stop| tab_stop.byte_offset <= distance)
|
||
.cloned()
|
||
.collect();
|
||
|
||
pretty_assertions::assert_eq!(
|
||
found_tab_stops,
|
||
expected_found_tab_stops,
|
||
"TabStopCursor output mismatch for distance {}. Input: {:?}",
|
||
distance,
|
||
input
|
||
);
|
||
|
||
let final_position = cursor.byte_offset();
|
||
if !found_tab_stops.is_empty() {
|
||
let last_tab_stop = found_tab_stops.last().unwrap();
|
||
assert!(
|
||
final_position >= last_tab_stop.byte_offset,
|
||
"Cursor final position {} is before last tab stop {}. Input: {:?}",
|
||
final_position,
|
||
last_tab_stop.byte_offset,
|
||
input
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|