Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use super::{
Highlights,
fold_map::Chunk,
wrap_map::{self, WrapEdit, WrapPatch, WrapPoint, WrapSnapshot},
};
use crate::{
EditorStyle, GutterDimensions,
display_map::{Companion, dimensions::RowDelta, wrap_map::WrapRow},
};
use collections::{Bound, HashMap, HashSet};
use gpui::{AnyElement, App, EntityId, Pixels, Window};
use language::{LanguageAwareStyling, Patch, Point};
use multi_buffer::{
Anchor, ExcerptBoundaryInfo, MultiBuffer, MultiBufferOffset, MultiBufferPoint, MultiBufferRow,
MultiBufferSnapshot, RowInfo, ToOffset, ToPoint as _,
};
use parking_lot::Mutex;
use std::{
cell::{Cell, RefCell},
cmp::{self, Ordering},
fmt::Debug,
ops::{Deref, DerefMut, Not, Range, RangeBounds, RangeInclusive},
sync::{
Arc,
atomic::{AtomicUsize, Ordering::SeqCst},
},
};
use sum_tree::{Bias, ContextLessSummary, Dimensions, SumTree, TreeMap};
use text::{BufferId, Edit};
use ui::{ElementId, IntoElement};
const NEWLINES: &[u8; rope::Chunk::MASK_BITS] = &[b'\n'; _];
const BULLETS: &[u8; rope::Chunk::MASK_BITS] = &[b'*'; _];
/// Tracks custom blocks such as diagnostics that should be displayed within buffer.
///
/// See the [`display_map` module documentation](crate::display_map) for more information.
pub struct BlockMap {
pub(super) wrap_snapshot: RefCell<WrapSnapshot>,
next_block_id: AtomicUsize,
custom_blocks: Vec<Arc<CustomBlock>>,
custom_blocks_by_id: TreeMap<CustomBlockId, Arc<CustomBlock>>,
transforms: RefCell<SumTree<Transform>>,
buffer_header_height: u32,
excerpt_header_height: u32,
pub(super) folded_buffers: HashSet<BufferId>,
buffers_with_disabled_headers: HashSet<BufferId>,
pub(super) deferred_edits: Cell<Patch<WrapRow>>,
}
pub struct BlockMapReader<'a> {
pub blocks: &'a Vec<Arc<CustomBlock>>,
pub snapshot: BlockSnapshot,
}
pub struct BlockMapWriter<'a> {
block_map: &'a mut BlockMap,
companion: Option<BlockMapWriterCompanion<'a>>,
}
/// Auxiliary data needed when modifying a BlockMap whose parent DisplayMap has a companion.
struct BlockMapWriterCompanion<'a> {
display_map_id: EntityId,
companion_wrap_snapshot: WrapSnapshot,
companion: &'a Companion,
inverse: Option<BlockMapInverseWriter<'a>>,
}
struct BlockMapInverseWriter<'a> {
companion_multibuffer: &'a MultiBuffer,
companion_writer: Box<BlockMapWriter<'a>>,
}
#[derive(Clone)]
pub struct BlockSnapshot {
pub(super) wrap_snapshot: WrapSnapshot,
transforms: SumTree<Transform>,
custom_blocks_by_id: TreeMap<CustomBlockId, Arc<CustomBlock>>,
pub(super) buffer_header_height: u32,
pub(super) excerpt_header_height: u32,
pub(super) buffers_with_disabled_headers: HashSet<BufferId>,
}
impl Deref for BlockSnapshot {
type Target = WrapSnapshot;
fn deref(&self) -> &Self::Target {
&self.wrap_snapshot
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct CustomBlockId(pub usize);
impl From<CustomBlockId> for ElementId {
fn from(val: CustomBlockId) -> Self {
val.0.into()
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SpacerId(pub usize);
/// A zero-indexed point in a text buffer consisting of a row and column
/// adjusted for inserted blocks, wrapped rows, tabs, folds and inlays.
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
pub struct BlockPoint(pub Point);
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
pub struct BlockRow(pub u32);
impl_for_row_types! {
BlockRow => RowDelta
}
impl BlockPoint {
pub fn row(&self) -> BlockRow {
BlockRow(self.0.row)
}
}
/// Forward-only cursor mapping [`WrapPoint`]s to [`BlockPoint`]s, reusing its
/// tree position across calls. This is the streaming equivalent of
/// [`BlockSnapshot::to_block_point`]; callers must provide non-decreasing wrap
/// points.
pub struct BlockPointCursor<'a> {
snapshot: &'a BlockSnapshot,
cursor: sum_tree::Cursor<'a, 'static, Transform, Dimensions<WrapRow, BlockRow>>,
}
impl BlockPointCursor<'_> {
/// Resets the cursor to the start so it can seek backward again.
pub fn reset(&mut self) {
self.cursor.reset();
}
pub fn map(&mut self, wrap_point: WrapPoint) -> BlockPoint {
let cursor = &mut self.cursor;
if cursor.did_seek() {
cursor.seek_forward(&wrap_point.row(), Bias::Right);
} else {
cursor.seek(&wrap_point.row(), Bias::Right);
}
if let Some(transform) = cursor.item() {
if transform.block.is_some() {
BlockPoint::new(cursor.start().1, 0)
} else {
let input_start = Point::new(cursor.start().0.0, 0);
let output_start = Point::new(cursor.start().1.0, 0);
let input_overshoot = wrap_point.0 - input_start;
BlockPoint(output_start + input_overshoot)
}
} else {
self.snapshot.max_point()
}
}
}
pub type RenderBlock = Arc<dyn Send + Sync + Fn(&mut BlockContext) -> AnyElement>;
/// Where to place a block.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum BlockPlacement<T> {
/// Place the block above the given position.
Above(T),
/// Place the block below the given position.
Below(T),
/// Place the block next the given position.
Near(T),
/// Replace the given range of positions with the block.
Replace(RangeInclusive<T>),
}
impl<T> BlockPlacement<T> {
pub fn start(&self) -> &T {
match self {
BlockPlacement::Above(position) => position,
BlockPlacement::Below(position) => position,
BlockPlacement::Near(position) => position,
BlockPlacement::Replace(range) => range.start(),
}
}
fn end(&self) -> &T {
match self {
BlockPlacement::Above(position) => position,
BlockPlacement::Below(position) => position,
BlockPlacement::Near(position) => position,
BlockPlacement::Replace(range) => range.end(),
}
}
pub fn as_ref(&self) -> BlockPlacement<&T> {
match self {
BlockPlacement::Above(position) => BlockPlacement::Above(position),
BlockPlacement::Below(position) => BlockPlacement::Below(position),
BlockPlacement::Near(position) => BlockPlacement::Near(position),
BlockPlacement::Replace(range) => BlockPlacement::Replace(range.start()..=range.end()),
}
}
pub fn map<R>(self, mut f: impl FnMut(T) -> R) -> BlockPlacement<R> {
match self {
BlockPlacement::Above(position) => BlockPlacement::Above(f(position)),
BlockPlacement::Below(position) => BlockPlacement::Below(f(position)),
BlockPlacement::Near(position) => BlockPlacement::Near(f(position)),
BlockPlacement::Replace(range) => {
let (start, end) = range.into_inner();
BlockPlacement::Replace(f(start)..=f(end))
}
}
}
fn tie_break(&self) -> u8 {
match self {
BlockPlacement::Replace(_) => 0,
BlockPlacement::Above(_) => 1,
BlockPlacement::Near(_) => 2,
BlockPlacement::Below(_) => 3,
}
}
}
impl BlockPlacement<Anchor> {
#[ztracing::instrument(skip_all)]
fn cmp(&self, other: &Self, buffer: &MultiBufferSnapshot) -> Ordering {
self.start()
.cmp(other.start(), buffer)
.then_with(|| other.end().cmp(self.end(), buffer))
.then_with(|| self.tie_break().cmp(&other.tie_break()))
}
#[ztracing::instrument(skip_all)]
fn to_wrap_row(&self, wrap_snapshot: &WrapSnapshot) -> Option<BlockPlacement<WrapRow>> {
let buffer_snapshot = wrap_snapshot.buffer_snapshot();
match self {
BlockPlacement::Above(position) => {
let mut position = position.to_point(buffer_snapshot);
position.column = 0;
let wrap_row = wrap_snapshot.make_wrap_point(position, Bias::Left).row();
Some(BlockPlacement::Above(wrap_row))
}
BlockPlacement::Near(position) => {
let mut position = position.to_point(buffer_snapshot);
position.column = buffer_snapshot.line_len(MultiBufferRow(position.row));
let wrap_row = wrap_snapshot.make_wrap_point(position, Bias::Left).row();
Some(BlockPlacement::Near(wrap_row))
}
BlockPlacement::Below(position) => {
let mut position = position.to_point(buffer_snapshot);
position.column = buffer_snapshot.line_len(MultiBufferRow(position.row));
let wrap_row = wrap_snapshot.make_wrap_point(position, Bias::Left).row();
Some(BlockPlacement::Below(wrap_row))
}
BlockPlacement::Replace(range) => {
let mut start = range.start().to_point(buffer_snapshot);
let mut end = range.end().to_point(buffer_snapshot);
if start == end {
None
} else {
start.column = 0;
let start_wrap_row = wrap_snapshot.make_wrap_point(start, Bias::Left).row();
end.column = buffer_snapshot.line_len(MultiBufferRow(end.row));
let end_wrap_row = wrap_snapshot.make_wrap_point(end, Bias::Left).row();
Some(BlockPlacement::Replace(start_wrap_row..=end_wrap_row))
}
}
}
}
}
pub struct CustomBlock {
pub id: CustomBlockId,
pub placement: BlockPlacement<Anchor>,
pub height: Option<u32>,
style: BlockStyle,
render: Arc<Mutex<RenderBlock>>,
priority: usize,
}
#[derive(Clone)]
pub struct BlockProperties<P> {
pub placement: BlockPlacement<P>,
// None if the block takes up no space
// (e.g. a horizontal line)
pub height: Option<u32>,
pub style: BlockStyle,
pub render: RenderBlock,
pub priority: usize,
}
impl<P: Debug> Debug for BlockProperties<P> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BlockProperties")
.field("placement", &self.placement)
.field("height", &self.height)
.field("style", &self.style)
.finish()
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub enum BlockStyle {
Fixed,
Flex,
/// Like `Flex` but doesn't use the gutter:
/// - block content scrolls with buffer content
/// - doesn't paint in gutter
Spacer,
Sticky,
}
#[derive(Debug, Default, Copy, Clone)]
pub struct EditorMargins {
pub gutter: GutterDimensions,
pub right: Pixels,
pub extended_right: Pixels,
}
#[derive(gpui::AppContext, gpui::VisualContext)]
pub struct BlockContext<'a, 'b> {
#[window]
pub window: &'a mut Window,
#[app]
pub app: &'b mut App,
pub anchor_x: Pixels,
pub max_width: Pixels,
pub margins: &'b EditorMargins,
pub em_width: Pixels,
pub line_height: Pixels,
pub block_id: BlockId,
pub height: u32,
pub selected: bool,
pub editor_style: &'b EditorStyle,
pub indent_guide_padding: Pixels,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BlockId {
ExcerptBoundary(Anchor),
FoldedBuffer(BufferId),
Custom(CustomBlockId),
Spacer(SpacerId),
}
impl From<BlockId> for ElementId {
fn from(value: BlockId) -> Self {
match value {
BlockId::Custom(CustomBlockId(id)) => ("Block", id).into(),
BlockId::ExcerptBoundary(anchor) => anchor.opaque_id().unwrap().into(),
BlockId::FoldedBuffer(id) => ("FoldedBuffer", EntityId::from(id.to_proto())).into(),
BlockId::Spacer(SpacerId(id)) => ("Spacer", id).into(),
}
}
}
impl std::fmt::Display for BlockId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Custom(id) => write!(f, "Block({id:?})"),
Self::ExcerptBoundary(id) => write!(f, "ExcerptBoundary({id:?})"),
Self::FoldedBuffer(id) => write!(f, "FoldedBuffer({id:?})"),
Self::Spacer(id) => write!(f, "Spacer({id:?})"),
}
}
}
#[derive(Clone, Debug)]
struct Transform {
summary: TransformSummary,
/// When `block` is `None`, the transform is isomorphic and passes input
/// wrap rows through as normal text.
block: Option<Block>,
}
#[derive(Clone)]
pub enum Block {
Custom(Arc<CustomBlock>),
FoldedBuffer {
first_excerpt: ExcerptBoundaryInfo,
height: u32,
},
ExcerptBoundary {
excerpt: ExcerptBoundaryInfo,
height: u32,
},
BufferHeader {
excerpt: ExcerptBoundaryInfo,
height: u32,
},
Spacer {
id: SpacerId,
height: u32,
is_below: bool,
},
}
impl Block {
pub fn id(&self) -> BlockId {
match self {
Block::Custom(block) => BlockId::Custom(block.id),
Block::ExcerptBoundary {
excerpt: next_excerpt,
..
} => BlockId::ExcerptBoundary(next_excerpt.start_anchor),
Block::FoldedBuffer { first_excerpt, .. } => {
BlockId::FoldedBuffer(first_excerpt.buffer_id())
}
Block::BufferHeader {
excerpt: next_excerpt,
..
} => BlockId::ExcerptBoundary(next_excerpt.start_anchor),
Block::Spacer { id, .. } => BlockId::Spacer(*id),
}
}
pub fn has_height(&self) -> bool {
match self {
Block::Custom(block) => block.height.is_some(),
Block::ExcerptBoundary { .. }
| Block::FoldedBuffer { .. }
| Block::BufferHeader { .. }
| Block::Spacer { .. } => true,
}
}
pub fn height(&self) -> u32 {
match self {
Block::Custom(block) => block.height.unwrap_or(0),
Block::ExcerptBoundary { height, .. }
| Block::FoldedBuffer { height, .. }
| Block::BufferHeader { height, .. }
| Block::Spacer { height, .. } => *height,
}
}
pub fn style(&self) -> BlockStyle {
match self {
Block::Custom(block) => block.style,
Block::ExcerptBoundary { .. }
| Block::FoldedBuffer { .. }
| Block::BufferHeader { .. } => BlockStyle::Sticky,
Block::Spacer { .. } => BlockStyle::Spacer,
}
}
fn place_above(&self) -> bool {
match self {
Block::Custom(block) => matches!(block.placement, BlockPlacement::Above(_)),
Block::FoldedBuffer { .. } => false,
Block::ExcerptBoundary { .. } => true,
Block::BufferHeader { .. } => true,
Block::Spacer { is_below, .. } => !*is_below,
}
}
pub fn place_near(&self) -> bool {
match self {
Block::Custom(block) => matches!(block.placement, BlockPlacement::Near(_)),
Block::FoldedBuffer { .. } => false,
Block::ExcerptBoundary { .. } => false,
Block::BufferHeader { .. } => false,
Block::Spacer { .. } => false,
}
}
fn place_below(&self) -> bool {
match self {
Block::Custom(block) => matches!(
block.placement,
BlockPlacement::Below(_) | BlockPlacement::Near(_)
),
Block::FoldedBuffer { .. } => false,
Block::ExcerptBoundary { .. } => false,
Block::BufferHeader { .. } => false,
Block::Spacer { is_below, .. } => *is_below,
}
}
fn is_replacement(&self) -> bool {
match self {
Block::Custom(block) => matches!(block.placement, BlockPlacement::Replace(_)),
Block::FoldedBuffer { .. } => true,
Block::ExcerptBoundary { .. } => false,
Block::BufferHeader { .. } => false,
Block::Spacer { .. } => false,
}
}
pub(crate) fn is_header(&self) -> bool {
match self {
Block::Custom(_) => false,
Block::FoldedBuffer { .. } => true,
Block::ExcerptBoundary { .. } => true,
Block::BufferHeader { .. } => true,
Block::Spacer { .. } => false,
}
}
pub fn is_buffer_header(&self) -> bool {
match self {
Block::Custom(_) => false,
Block::FoldedBuffer { .. } => true,
Block::ExcerptBoundary { .. } => false,
Block::BufferHeader { .. } => true,
Block::Spacer { .. } => false,
}
}
}
impl Debug for Block {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Custom(block) => f.debug_struct("Custom").field("block", block).finish(),
Self::FoldedBuffer {
first_excerpt,
height,
} => f
.debug_struct("FoldedBuffer")
.field("first_excerpt", &first_excerpt)
.field("height", height)
.finish(),
Self::ExcerptBoundary { excerpt, height } => f
.debug_struct("ExcerptBoundary")
.field("excerpt", excerpt)
.field("height", height)
.finish(),
Self::BufferHeader { excerpt, height } => f
.debug_struct("BufferHeader")
.field("excerpt", excerpt)
.field("height", height)
.finish(),
Self::Spacer {
id,
height,
is_below: _,
} => f
.debug_struct("Spacer")
.field("id", id)
.field("height", height)
.finish(),
}
}
}
#[derive(Clone, Debug, Default)]
struct TransformSummary {
input_rows: WrapRow,
output_rows: BlockRow,
longest_row: BlockRow,
longest_row_chars: u32,
has_replacement_blocks: bool,
}
pub struct BlockChunks<'a> {
transforms: sum_tree::Cursor<'a, 'static, Transform, Dimensions<BlockRow, WrapRow>>,
input_chunks: wrap_map::WrapChunks<'a>,
input_chunk: Chunk<'a>,
output_row: BlockRow,
max_output_row: BlockRow,
line_count_overflow: RowDelta,
masked: bool,
}
#[derive(Clone)]
pub struct BlockRows<'a> {
transforms: sum_tree::Cursor<'a, 'static, Transform, Dimensions<BlockRow, WrapRow>>,
input_rows: wrap_map::WrapRows<'a>,
output_row: BlockRow,
started: bool,
}
#[derive(Clone, Copy)]
pub struct CompanionView<'a> {
display_map_id: EntityId,
companion_wrap_snapshot: &'a WrapSnapshot,
companion_wrap_edits: &'a WrapPatch,
companion: &'a Companion,
}
impl<'a> CompanionView<'a> {
pub(crate) fn new(
display_map_id: EntityId,
companion_wrap_snapshot: &'a WrapSnapshot,
companion_wrap_edits: &'a WrapPatch,
companion: &'a Companion,
) -> Self {
Self {
display_map_id,
companion_wrap_snapshot,
companion_wrap_edits,
companion,
}
}
}
impl<'a> From<CompanionViewMut<'a>> for CompanionView<'a> {
fn from(view_mut: CompanionViewMut<'a>) -> Self {
Self {
display_map_id: view_mut.display_map_id,
companion_wrap_snapshot: view_mut.companion_wrap_snapshot,
companion_wrap_edits: view_mut.companion_wrap_edits,
companion: view_mut.companion,
}
}
}
impl<'a> From<&'a CompanionViewMut<'a>> for CompanionView<'a> {
fn from(view_mut: &'a CompanionViewMut<'a>) -> Self {
Self {
display_map_id: view_mut.display_map_id,
companion_wrap_snapshot: view_mut.companion_wrap_snapshot,
companion_wrap_edits: view_mut.companion_wrap_edits,
companion: view_mut.companion,
}
}
}
pub struct CompanionViewMut<'a> {
display_map_id: EntityId,
companion_display_map_id: EntityId,
companion_wrap_snapshot: &'a WrapSnapshot,
companion_wrap_edits: &'a WrapPatch,
companion_multibuffer: &'a MultiBuffer,
companion_block_map: &'a mut BlockMap,
companion: &'a Companion,
}
impl<'a> CompanionViewMut<'a> {
pub(crate) fn new(
display_map_id: EntityId,
companion_display_map_id: EntityId,
companion_wrap_snapshot: &'a WrapSnapshot,
companion_wrap_edits: &'a WrapPatch,
companion_multibuffer: &'a MultiBuffer,
companion: &'a Companion,
companion_block_map: &'a mut BlockMap,
) -> Self {
Self {
display_map_id,
companion_display_map_id,
companion_wrap_snapshot,
companion_wrap_edits,
companion_multibuffer,
companion,
companion_block_map,
}
}
}
impl BlockMap {
#[ztracing::instrument(skip_all)]
pub fn new(
wrap_snapshot: WrapSnapshot,
buffer_header_height: u32,
excerpt_header_height: u32,
) -> Self {
let row_count = wrap_snapshot.max_point().row() + WrapRow(1);
let mut transforms = SumTree::default();
push_isomorphic(&mut transforms, row_count - WrapRow(0), &wrap_snapshot);
let map = Self {
next_block_id: AtomicUsize::new(0),
custom_blocks: Vec::new(),
custom_blocks_by_id: TreeMap::default(),
folded_buffers: HashSet::default(),
buffers_with_disabled_headers: HashSet::default(),
transforms: RefCell::new(transforms),
wrap_snapshot: RefCell::new(wrap_snapshot.clone()),
buffer_header_height,
excerpt_header_height,
deferred_edits: Cell::default(),
};
map.sync(
&wrap_snapshot,
Patch::new(vec![Edit {
old: WrapRow(0)..row_count,
new: WrapRow(0)..row_count,
}]),
None,
);
map
}
#[ztracing::instrument(skip_all)]
pub(crate) fn read(
&self,
wrap_snapshot: WrapSnapshot,
edits: WrapPatch,
companion_view: Option<CompanionView>,
) -> BlockMapReader<'_> {
self.sync(&wrap_snapshot, edits, companion_view);
*self.wrap_snapshot.borrow_mut() = wrap_snapshot.clone();
BlockMapReader {
blocks: &self.custom_blocks,
snapshot: BlockSnapshot {
wrap_snapshot,
transforms: self.transforms.borrow().clone(),
custom_blocks_by_id: self.custom_blocks_by_id.clone(),
buffer_header_height: self.buffer_header_height,
excerpt_header_height: self.excerpt_header_height,
buffers_with_disabled_headers: self.buffers_with_disabled_headers.clone(),
},
}
}
#[ztracing::instrument(skip_all)]
pub(crate) fn write<'a>(
&'a mut self,
wrap_snapshot: WrapSnapshot,
edits: WrapPatch,
companion_view: Option<CompanionViewMut<'a>>,
) -> BlockMapWriter<'a> {
self.sync(
&wrap_snapshot,
edits.clone(),
companion_view.as_ref().map(CompanionView::from),
);
*self.wrap_snapshot.borrow_mut() = wrap_snapshot.clone();
let companion = if let Some(companion_view) = companion_view {
companion_view.companion_block_map.sync(
companion_view.companion_wrap_snapshot,
companion_view.companion_wrap_edits.clone(),
Some(CompanionView::new(
companion_view.companion_display_map_id,
&wrap_snapshot,
&edits,
companion_view.companion,
)),
);
*companion_view
.companion_block_map
.wrap_snapshot
.borrow_mut() = companion_view.companion_wrap_snapshot.clone();
Some(BlockMapWriterCompanion {
display_map_id: companion_view.display_map_id,
companion_wrap_snapshot: companion_view.companion_wrap_snapshot.clone(),
companion: companion_view.companion,
inverse: Some(BlockMapInverseWriter {
companion_multibuffer: companion_view.companion_multibuffer,
companion_writer: Box::new(BlockMapWriter {
block_map: companion_view.companion_block_map,
companion: Some(BlockMapWriterCompanion {
display_map_id: companion_view.companion_display_map_id,
companion_wrap_snapshot: wrap_snapshot,
companion: companion_view.companion,
inverse: None,
}),
}),
}),
})
} else {
None
};
BlockMapWriter {
block_map: self,
companion,
}
}
// Warning: doesn't sync the block map, use advisedly
pub(crate) fn insert_block_raw(
&mut self,
block: BlockProperties<Anchor>,
buffer: &MultiBufferSnapshot,
) -> CustomBlockId {
let id = CustomBlockId(self.next_block_id.fetch_add(1, SeqCst));
let block_ix = match self
.custom_blocks
.binary_search_by(|probe| probe.placement.cmp(&block.placement, &buffer))
{
Ok(ix) | Err(ix) => ix,
};
let new_block = Arc::new(CustomBlock {
id,
placement: block.placement.clone(),
height: block.height,
style: block.style,
render: Arc::new(Mutex::new(block.render.clone())),
priority: block.priority,
});
self.custom_blocks.insert(block_ix, new_block.clone());
self.custom_blocks_by_id.insert(id, new_block);
id
}
// Warning: doesn't sync the block map, use advisedly
pub(crate) fn retain_blocks_raw(&mut self, pred: &mut dyn FnMut(&Arc<CustomBlock>) -> bool) {
let mut ids_to_remove = HashSet::default();
self.custom_blocks.retain(|block| {
let keep = pred(block);
if !keep {
ids_to_remove.insert(block.id);
}
keep
});
self.custom_blocks_by_id
.retain(|id, _| !ids_to_remove.contains(id));
}
// Warning: doesn't sync the block map, use advisedly
pub(crate) fn blocks_raw(&self) -> impl Iterator<Item = &Arc<CustomBlock>> {
self.custom_blocks.iter()
}
#[ztracing::instrument(skip_all, fields(edits = ?edits))]
fn sync(
&self,
wrap_snapshot: &WrapSnapshot,
mut edits: WrapPatch,
companion_view: Option<CompanionView>,
) {
let buffer = wrap_snapshot.buffer_snapshot();
edits = self.deferred_edits.take().compose(edits);
let max_point = wrap_snapshot.max_point();
// Handle changing the last excerpt if it is empty.
if buffer.trailing_excerpt_update_count()
!= self
.wrap_snapshot
.borrow()
.buffer_snapshot()
.trailing_excerpt_update_count()
{
let edit_start = wrap_snapshot.prev_row_boundary(max_point);
let edit_end = max_point.row() + WrapRow(1); // this is end of file
edits = edits.compose([WrapEdit {
old: edit_start..edit_end,
new: edit_start..edit_end,
}]);
}
// Pull in companion edits to ensure we recompute spacers in ranges that have changed in the companion.
if let Some(CompanionView {
companion_wrap_snapshot: companion_new_snapshot,
companion_wrap_edits: companion_edits,
companion,
display_map_id,
..
}) = companion_view
{
let mut companion_edits_in_my_space: Vec<WrapEdit> = companion_edits
.clone()
.into_inner()
.iter()
.map(|edit| {
let companion_start = companion_new_snapshot
.to_point(WrapPoint::new(edit.new.start, 0), Bias::Left);
let companion_end = companion_new_snapshot
.to_point(WrapPoint::new(edit.new.end, 0), Bias::Left);
let my_start = companion
.convert_point_from_companion(
display_map_id,
wrap_snapshot.buffer_snapshot(),
companion_new_snapshot.buffer_snapshot(),
companion_start,
)
.start;
let my_end = companion
.convert_point_from_companion(
display_map_id,
wrap_snapshot.buffer_snapshot(),
companion_new_snapshot.buffer_snapshot(),
companion_end,
)
.end;
let mut my_start = wrap_snapshot.make_wrap_point(my_start, Bias::Left);
let mut my_end = wrap_snapshot.make_wrap_point(my_end, Bias::Left);
// TODO(split-diff) should use trailing_excerpt_update_count for the second case
if my_end.column() > 0 || my_end == max_point {
*my_end.row_mut() += 1;
*my_end.column_mut() = 0;
}
// Empty edits won't survive Patch::compose, but we still need to make sure
// we recompute spacers when we get them.
if my_start.row() == my_end.row() {
if my_end.row() <= max_point.row() {
*my_end.row_mut() += 1;
*my_end.column_mut() = 0;
} else if my_start.row() > WrapRow(0) {
*my_start.row_mut() += 1;
*my_start.column_mut() = 0;
}
}
WrapEdit {
old: my_start.row()..my_end.row(),
new: my_start.row()..my_end.row(),
}
})
.collect();
companion_edits_in_my_space.sort_by_key(|edit| edit.old.start);
let mut merged_edits: Vec<WrapEdit> = Vec::new();
for edit in companion_edits_in_my_space {
if let Some(last) = merged_edits.last_mut() {
if edit.old.start <= last.old.end {
last.old.end = last.old.end.max(edit.old.end);
last.new.end = last.new.end.max(edit.new.end);
continue;
}
}
merged_edits.push(edit);
}
edits = edits.compose(merged_edits);
}
let edits = edits.into_inner();
if edits.is_empty() {
return;
}
let mut transforms = self.transforms.borrow_mut();
let mut new_transforms = SumTree::default();
let mut cursor = transforms.cursor::<WrapRow>(());
let mut last_block_ix = 0;
let mut blocks_in_edit = Vec::new();
let mut edits = edits.into_iter().peekable();
let mut inlay_point_cursor = wrap_snapshot.inlay_point_cursor();
let mut tab_point_cursor = wrap_snapshot.tab_point_cursor();
let mut fold_point_cursor = wrap_snapshot.fold_point_cursor();
let mut wrap_point_cursor = wrap_snapshot.wrap_point_cursor();
while let Some(edit) = edits.next() {
let span = ztracing::debug_span!("while edits", edit = ?edit);
let _enter = span.enter();
let mut old_start = edit.old.start;
let mut new_start = edit.new.start;
// Only preserve transforms that:
// * Strictly precedes this edit
// * 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), ());
if let Some(transform) = cursor.item()
&& transform.summary.input_rows > WrapRow(0)
&& cursor.end() == old_start
&& transform.block.as_ref().is_none_or(|b| !b.is_replacement())
{
// Preserve the transform (push and next)
new_transforms.push(transform.clone(), ());
cursor.next();
// Preserve below blocks at start of edit
while let Some(transform) = cursor.item() {
if transform.block.as_ref().is_some_and(|b| b.place_below()) {
new_transforms.push(transform.clone(), ());
cursor.next();
} else {
break;
}
}
}
// Ensure the edit starts at a transform boundary.
// If the edit starts within an isomorphic transform, preserve its prefix
// If the edit lands within a replacement block, expand the edit to include the start of the replaced input range
// The cursor can sit past the end of the tree when a companion edit
// is anchored at the new end-of-file and maps to `old_start` at the
// very end of the old transforms; in that case there is no transform
// preceding the edit and nothing to preserve.
let transform_rows_before_edit = old_start - *cursor.start();
if transform_rows_before_edit > RowDelta(0)
&& let Some(transform) = cursor.item()
{
if transform.block.is_none() {
// Preserve any portion of the old isomorphic transform that precedes this edit.
push_isomorphic(
&mut new_transforms,
transform_rows_before_edit,
wrap_snapshot,
);
} else {
// We landed within a block that replaces some lines, so we
// extend the edit to start at the beginning of the
// replacement.
debug_assert!(transform.summary.input_rows > WrapRow(0));
old_start -= transform_rows_before_edit;
new_start -= transform_rows_before_edit;
}
}
// Decide where the edit ends
// * It should end at a transform boundary
// * Coalesce edits that intersect the same transform
let mut old_end = edit.old.end;
let mut new_end = edit.new.end;
loop {
let span = ztracing::debug_span!("decide where edit ends loop");
let _enter = span.enter();
// Seek to the transform starting at or after the end of the edit
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() - old_end;
old_end += transform_rows_after_edit;
new_end += transform_rows_after_edit;
// Combine this edit with any subsequent edits that intersect the same transform.
while let Some(next_edit) = edits.peek() {
if next_edit.old.start <= *cursor.start() {
old_end = next_edit.old.end;
new_end = next_edit.new.end;
cursor.seek(&old_end, Bias::Left);
cursor.next();
edits.next();
} else {
break;
}
}
if *cursor.start() == old_end {
break;
}
}
// Discard below blocks at the end of the edit. They'll be reconstructed.
while let Some(transform) = cursor.item() {
if transform
.block
.as_ref()
.is_some_and(|b| b.place_below() || matches!(b, Block::Spacer { .. }))
{
cursor.next();
} else {
break;
}
}
// Find the blocks within this edited region.
let new_buffer_start = wrap_snapshot.to_point(WrapPoint::new(new_start, 0), Bias::Left);
let start_bound = Bound::Included(new_buffer_start);
let start_block_ix =
match self.custom_blocks[last_block_ix..].binary_search_by(|probe| {
probe
.start()
.to_point(buffer)
.cmp(&new_buffer_start)
// Move left until we find the index of the first block starting within this edit
.then(Ordering::Greater)
}) {
Ok(ix) | Err(ix) => last_block_ix + ix,
};
let end_bound;
let end_block_ix = if new_end > max_point.row() {
end_bound = Bound::Unbounded;
self.custom_blocks.len()
} else {
let new_buffer_end = wrap_snapshot.to_point(WrapPoint::new(new_end, 0), Bias::Left);
end_bound = Bound::Excluded(new_buffer_end);
match self.custom_blocks[start_block_ix..].binary_search_by(|probe| {
probe
.start()
.to_point(buffer)
.cmp(&new_buffer_end)
.then(Ordering::Greater)
}) {
Ok(ix) | Err(ix) => start_block_ix + ix,
}
};
last_block_ix = end_block_ix;
debug_assert!(blocks_in_edit.is_empty());
// + 8 is chosen arbitrarily to cover some multibuffer headers
blocks_in_edit
.reserve(end_block_ix - start_block_ix + if buffer.is_singleton() { 0 } else { 8 });
blocks_in_edit.extend(
self.custom_blocks[start_block_ix..end_block_ix]
.iter()
.filter_map(|block| {
let placement = block.placement.to_wrap_row(wrap_snapshot)?;
if !matches!(placement, BlockPlacement::Replace(_))
&& wrap_snapshot.intersects_fold(Point::new(
block
.placement
.start()
.to_point(wrap_snapshot.buffer_snapshot())
.row,
0,
))
{
return None;
}
if let BlockPlacement::Above(row) = placement
&& row < new_start
{
return None;
}
Some((placement, Block::Custom(block.clone())))
}),
);
blocks_in_edit.extend(self.header_and_footer_blocks(
buffer,
(start_bound, end_bound),
|point, bias| {
wrap_point_cursor
.map(
tab_point_cursor.map(
fold_point_cursor.map(inlay_point_cursor.map(point, bias), bias),
),
)
.row()
},
));
if let Some(CompanionView {
companion_wrap_snapshot: companion_snapshot,
companion,
display_map_id,
..
}) = companion_view
{
blocks_in_edit.extend(self.spacer_blocks(
(start_bound, end_bound),
wrap_snapshot,
companion_snapshot,
companion,
display_map_id,
));
}
BlockMap::sort_blocks(&mut blocks_in_edit);
// For each of these blocks, insert a new isomorphic transform preceding the block,
// and then insert the block itself.
for (block_placement, block) in blocks_in_edit.drain(..) {
let span =
ztracing::debug_span!("for block in edits", block_height = block.height());
let _enter = span.enter();
let mut summary = TransformSummary {
input_rows: WrapRow(0),
output_rows: BlockRow(block.height()),
longest_row: BlockRow(0),
longest_row_chars: 0,
has_replacement_blocks: false,
};
let rows_before_block;
let input_rows = new_transforms.summary().input_rows;
match &block_placement {
&BlockPlacement::Above(position) => {
let Some(delta) = position.checked_sub(input_rows) else {
continue;
};
rows_before_block = delta;
}
&BlockPlacement::Near(position) | &BlockPlacement::Below(position) => {
let Some(delta) = (position + RowDelta(1)).checked_sub(input_rows) else {
continue;
};
rows_before_block = delta;
}
BlockPlacement::Replace(range) => {
let Some(delta) = range.start().checked_sub(input_rows) else {
continue;
};
rows_before_block = delta;
summary.input_rows = WrapRow(1) + (*range.end() - *range.start());
}
}
push_isomorphic(&mut new_transforms, rows_before_block, wrap_snapshot);
new_transforms.push(
Transform {
summary,
block: Some(block),
},
(),
);
}
// Insert an isomorphic transform after the final block.
let rows_after_last_block =
RowDelta(new_end.0).saturating_sub(RowDelta(new_transforms.summary().input_rows.0));
push_isomorphic(&mut new_transforms, rows_after_last_block, wrap_snapshot);
}
new_transforms.append(cursor.suffix(), ());
debug_assert_eq!(
new_transforms.summary().input_rows,
wrap_snapshot.max_point().row() + WrapRow(1),
);
drop(cursor);
*transforms = new_transforms;
}
#[ztracing::instrument(skip_all)]
pub fn replace_blocks(&mut self, mut renderers: HashMap<CustomBlockId, RenderBlock>) {
for block in &mut self.custom_blocks {
if let Some(render) = renderers.remove(&block.id) {
*block.render.lock() = render;
}
}
}
/// Guarantees that `wrap_row_for` is called with points in increasing order.
#[ztracing::instrument(skip_all)]
fn header_and_footer_blocks<'a, R, T>(
&'a self,
buffer: &'a multi_buffer::MultiBufferSnapshot,
range: R,
mut wrap_row_for: impl 'a + FnMut(Point, Bias) -> WrapRow,
) -> impl Iterator<Item = (BlockPlacement<WrapRow>, Block)> + 'a
where
R: RangeBounds<T>,
T: multi_buffer::ToOffset,
{
let mut boundaries = buffer.excerpt_boundaries_in_range(range).peekable();
std::iter::from_fn(move || {
loop {
let excerpt_boundary = boundaries.next()?;
let wrap_row = wrap_row_for(Point::new(excerpt_boundary.row.0, 0), Bias::Left);
let new_buffer_id = match (&excerpt_boundary.prev, &excerpt_boundary.next) {
(None, next) => Some(next.buffer_id()),
(Some(prev), next) => {
if prev.buffer_id() != next.buffer_id() {
Some(next.buffer_id())
} else {
None
}
}
};
let mut height = 0;
if let Some(new_buffer_id) = new_buffer_id {
let first_excerpt = excerpt_boundary.next.clone();
if self.buffers_with_disabled_headers.contains(&new_buffer_id) {
continue;
}
if self.folded_buffers.contains(&new_buffer_id) && buffer.show_headers() {
let mut last_excerpt_end_row = first_excerpt.end_row;
while let Some(next_boundary) = boundaries.peek() {
if next_boundary.next.buffer_id() == new_buffer_id {
last_excerpt_end_row = next_boundary.next.end_row;
} else {
break;
}
boundaries.next();
}
let wrap_end_row = wrap_row_for(
Point::new(
last_excerpt_end_row.0,
buffer.line_len(last_excerpt_end_row),
),
Bias::Right,
);
return Some((
BlockPlacement::Replace(wrap_row..=wrap_end_row),
Block::FoldedBuffer {
height: height + self.buffer_header_height,
first_excerpt,
},
));
}
}
let starts_new_buffer = new_buffer_id.is_some();
let block = if starts_new_buffer && buffer.show_headers() {
height += self.buffer_header_height;
Block::BufferHeader {
excerpt: excerpt_boundary.next,
height,
}
} else if excerpt_boundary.prev.is_some() {
height += self.excerpt_header_height;
Block::ExcerptBoundary {
excerpt: excerpt_boundary.next,
height,
}
} else {
continue;
};
return Some((BlockPlacement::Above(wrap_row), block));
}
})
}
fn spacer_blocks(
&self,
bounds: (Bound<MultiBufferPoint>, Bound<MultiBufferPoint>),
wrap_snapshot: &WrapSnapshot,
companion_snapshot: &WrapSnapshot,
companion: &Companion,
display_map_id: EntityId,
) -> Vec<(BlockPlacement<WrapRow>, Block)> {
let our_buffer = wrap_snapshot.buffer_snapshot();
let companion_buffer = companion_snapshot.buffer_snapshot();
let range = match bounds {
(Bound::Included(start), Bound::Excluded(end)) => start..end,
(Bound::Included(start), Bound::Unbounded) => start..wrap_snapshot.buffer().max_point(),
_ => unreachable!(),
};
let mut patches = companion.convert_rows_to_companion(
display_map_id,
companion_buffer,
our_buffer,
range,
);
if let Some(patch) = patches.last()
&& let Bound::Excluded(end) = bounds.1
&& end == wrap_snapshot.buffer().max_point()
&& patch.source_excerpt_range.is_empty()
{
patches.pop();
}
let mut our_inlay_point_cursor = wrap_snapshot.inlay_point_cursor();
let mut our_fold_point_cursor = wrap_snapshot.fold_point_cursor();
let mut our_tab_point_cursor = wrap_snapshot.tab_point_cursor();
let mut our_wrap_point_cursor = wrap_snapshot.wrap_point_cursor();
let mut our_wrapper = |our_point: Point, bias: Bias| {
our_wrap_point_cursor
.map(our_tab_point_cursor.map(
our_fold_point_cursor.map(our_inlay_point_cursor.map(our_point, bias), bias),
))
.row()
};
let mut companion_wrapper = |their_point: Point, bias: Bias| {
// TODO(split-diff) fix companion points being passed in decreasing order
let inlay_point = companion_snapshot
.inlay_snapshot
.inlay_point_cursor()
.map(their_point, bias);
let fold_point = companion_snapshot.to_fold_point(inlay_point, bias);
let tab_point = companion_snapshot.fold_point_to_tab_point(fold_point);
companion_snapshot.tab_point_to_wrap_point(tab_point).row()
};
fn determine_spacer(
our_wrapper: &mut dyn FnMut(Point, Bias) -> WrapRow,
companion_wrapper: &mut dyn FnMut(Point, Bias) -> WrapRow,
our_point: Point,
their_point: Point,
delta: i32,
bias: Bias,
) -> (i32, Option<(WrapRow, u32)>) {
let our_wrap = our_wrapper(our_point, bias);
let companion_wrap = companion_wrapper(their_point, bias);
let new_delta = companion_wrap.0 as i32 - our_wrap.0 as i32;
let spacer = if new_delta > delta {
let height = (new_delta - delta) as u32;
Some((our_wrap, height))
} else {
None
};
(new_delta, spacer)
}
let mut result = Vec::new();
for excerpt in patches {
let mut source_points = (excerpt.edited_range.start.row..=excerpt.edited_range.end.row)
.map(|row| MultiBufferPoint::new(row, 0))
.chain(if excerpt.edited_range.end.column > 0 {
Some(excerpt.edited_range.end)
} else {
None
})
.peekable();
let last_source_point = if excerpt.edited_range.end.column > 0 {
excerpt.edited_range.end
} else {
MultiBufferPoint::new(excerpt.edited_range.end.row, 0)
};
let Some(first_point) = source_points.peek().copied() else {
continue;
};
let edit_for_first_point = excerpt.patch.edit_for_old_position(first_point);
// Because we calculate spacers based on differences in wrap row
// counts between the RHS and LHS for corresponding buffer points,
// we need to calibrate our expectations based on the difference
// in counts before the start of the edit. This difference in
// counts should have been balanced already by spacers above this
// edit, so we only need to insert spacers for when the difference
// in counts diverges from that baseline value.
let (our_baseline, their_baseline) = if edit_for_first_point.old.start < first_point {
// Case 1: We are inside a hunk/group--take the start of the hunk/group on both sides as the baseline.
(
edit_for_first_point.old.start,
edit_for_first_point.new.start,
)
} else if first_point.row > excerpt.source_excerpt_range.start.row {
// Case 2: We are not inside a hunk/group--go back by one row to find the baseline.
let prev_point = Point::new(first_point.row - 1, 0);
let edit_for_prev_point = excerpt.patch.edit_for_old_position(prev_point);
(prev_point, edit_for_prev_point.new.end)
} else {
// Case 3: We are at the start of the excerpt--no previous row to use as the baseline.
(first_point, edit_for_first_point.new.start)
};
let our_baseline = our_wrapper(our_baseline, Bias::Left);
let their_baseline = companion_wrapper(
their_baseline.min(excerpt.target_excerpt_range.end),
Bias::Left,
);
let mut delta = their_baseline.0 as i32 - our_baseline.0 as i32;
while let Some(source_point) = source_points.next() {
let mut current_boundary = source_point;
let current_edit = excerpt.patch.edit_for_old_position(current_boundary);
let current_range = current_edit.new;
if current_boundary.column > 0 {
debug_assert_eq!(current_boundary, excerpt.source_excerpt_range.end);
break;
}
if current_edit.old.start < current_boundary {
while let Some(next_point) = source_points.peek().copied() {
let edit_for_next_point = excerpt.patch.edit_for_old_position(next_point);
if edit_for_next_point.new.end > current_range.end {
break;
}
current_boundary = next_point;
source_points.next();
}
let (new_delta, spacer) = determine_spacer(
&mut our_wrapper,
&mut companion_wrapper,
current_boundary,
current_range.end.min(excerpt.target_excerpt_range.end),
delta,
Bias::Left,
);
delta = new_delta;
if let Some((wrap_row, height)) = spacer {
result.push((
BlockPlacement::Above(wrap_row),
Block::Spacer {
id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
height,
is_below: false,
},
));
}
continue;
}
let (delta_at_start, mut spacer_at_start) = determine_spacer(
&mut our_wrapper,
&mut companion_wrapper,
current_boundary,
current_range.start.min(excerpt.target_excerpt_range.end),
delta,
Bias::Left,
);
delta = delta_at_start;
while let Some(next_point) = source_points.peek().copied() {
let edit_for_next_point = excerpt.patch.edit_for_old_position(next_point);
if edit_for_next_point.new.end > current_range.end {
break;
}
if let Some((wrap_row, height)) = spacer_at_start.take() {
result.push((
BlockPlacement::Above(wrap_row),
Block::Spacer {
id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
height,
is_below: false,
},
));
}
current_boundary = next_point;
source_points.next();
}
if current_boundary.column > 0 {
debug_assert_eq!(current_boundary, excerpt.source_excerpt_range.end);
break;
}
let edit_for_current_boundary =
excerpt.patch.edit_for_old_position(current_boundary);
let spacer_at_end = if current_boundary == edit_for_current_boundary.old.end {
let (delta_at_end, spacer_at_end) = determine_spacer(
&mut our_wrapper,
&mut companion_wrapper,
current_boundary,
current_range.end.min(excerpt.target_excerpt_range.end),
delta,
Bias::Left,
);
delta = delta_at_end;
spacer_at_end
} else {
None
};
if let Some((wrap_row, mut height)) = spacer_at_start {
if let Some((_, additional_height)) = spacer_at_end {
height += additional_height;
}
result.push((
BlockPlacement::Above(wrap_row),
Block::Spacer {
id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
height,
is_below: false,
},
));
} else if let Some((wrap_row, height)) = spacer_at_end {
result.push((
BlockPlacement::Above(wrap_row),
Block::Spacer {
id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
height,
is_below: false,
},
));
}
}
if last_source_point == excerpt.source_excerpt_range.end {
let (_new_delta, spacer) = determine_spacer(
&mut our_wrapper,
&mut companion_wrapper,
last_source_point,
excerpt.target_excerpt_range.end,
delta,
Bias::Right,
);
if let Some((wrap_row, height)) = spacer {
result.push((
BlockPlacement::Below(wrap_row),
Block::Spacer {
id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
height,
is_below: true,
},
));
}
}
}
result
}
#[ztracing::instrument(skip_all)]
fn sort_blocks(blocks: &mut Vec<(BlockPlacement<WrapRow>, Block)>) {
blocks.sort_unstable_by(|(placement_a, block_a), (placement_b, block_b)| {
placement_a
.start()
.cmp(placement_b.start())
.then_with(|| placement_b.end().cmp(placement_a.end()))
.then_with(|| placement_a.tie_break().cmp(&placement_b.tie_break()))
.then_with(|| {
if block_a.is_header() {
Ordering::Less
} else if block_b.is_header() {
Ordering::Greater
} else {
Ordering::Equal
}
})
.then_with(|| match (block_a, block_b) {
(
Block::ExcerptBoundary {
excerpt: excerpt_a, ..
}
| Block::BufferHeader {
excerpt: excerpt_a, ..
},
Block::ExcerptBoundary {
excerpt: excerpt_b, ..
}
| Block::BufferHeader {
excerpt: excerpt_b, ..
},
) => Some(excerpt_a.start_text_anchor().opaque_id())
.cmp(&Some(excerpt_b.start_text_anchor().opaque_id())),
(
Block::ExcerptBoundary { .. } | Block::BufferHeader { .. },
Block::Spacer { .. } | Block::Custom(_),
) => Ordering::Less,
(
Block::Spacer { .. } | Block::Custom(_),
Block::ExcerptBoundary { .. } | Block::BufferHeader { .. },
) => Ordering::Greater,
(Block::Spacer { .. }, Block::Custom(_)) => Ordering::Less,
(Block::Custom(_), Block::Spacer { .. }) => Ordering::Greater,
(Block::Custom(block_a), Block::Custom(block_b)) => block_a
.priority
.cmp(&block_b.priority)
.then_with(|| block_a.id.cmp(&block_b.id)),
_ => {
unreachable!("comparing blocks: {block_a:?} vs {block_b:?}")
}
})
});
blocks.dedup_by(|right, left| match (left.0.clone(), right.0.clone()) {
(BlockPlacement::Replace(range), BlockPlacement::Above(row))
| (BlockPlacement::Replace(range), BlockPlacement::Near(row))
| (BlockPlacement::Replace(range), BlockPlacement::Below(row)) => range.contains(&row),
(BlockPlacement::Replace(range_a), BlockPlacement::Replace(range_b)) => {
if range_a.end() >= range_b.start() && range_a.start() <= range_b.end() {
left.0 = BlockPlacement::Replace(
*range_a.start()..=*range_a.end().max(range_b.end()),
);
true
} else {
false
}
}
_ => false,
});
}
}
#[ztracing::instrument(skip(tree, wrap_snapshot))]
fn push_isomorphic(tree: &mut SumTree<Transform>, rows: RowDelta, wrap_snapshot: &WrapSnapshot) {
if rows == RowDelta(0) {
return;
}
let wrap_row_start = tree.summary().input_rows;
let wrap_row_end = wrap_row_start + rows;
let wrap_summary = wrap_snapshot.text_summary_for_range(wrap_row_start..wrap_row_end);
let summary = TransformSummary {
input_rows: WrapRow(rows.0),
output_rows: BlockRow(rows.0),
longest_row: BlockRow(wrap_summary.longest_row),
longest_row_chars: wrap_summary.longest_row_chars,
has_replacement_blocks: false,
};
let mut merged = false;
tree.update_last(
|last_transform| {
if last_transform.block.is_none() {
last_transform.summary.add_summary(&summary);
merged = true;
}
},
(),
);
if !merged {
tree.push(
Transform {
summary,
block: None,
},
(),
);
}
}
impl BlockPoint {
pub fn new(row: BlockRow, column: u32) -> Self {
Self(Point::new(row.0, column))
}
}
impl Deref for BlockPoint {
type Target = Point;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl std::ops::DerefMut for BlockPoint {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl Deref for BlockMapReader<'_> {
type Target = BlockSnapshot;
fn deref(&self) -> &Self::Target {
&self.snapshot
}
}
impl DerefMut for BlockMapReader<'_> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.snapshot
}
}
impl BlockMapReader<'_> {
#[ztracing::instrument(skip_all)]
pub fn row_for_block(&self, block_id: CustomBlockId) -> Option<BlockRow> {
let block = self.blocks.iter().find(|block| block.id == block_id)?;
let buffer_row = block
.start()
.to_point(self.wrap_snapshot.buffer_snapshot())
.row;
let wrap_row = self
.wrap_snapshot
.make_wrap_point(Point::new(buffer_row, 0), Bias::Left)
.row();
let start_wrap_row = self
.wrap_snapshot
.prev_row_boundary(WrapPoint::new(wrap_row, 0));
let end_wrap_row = self
.wrap_snapshot
.next_row_boundary(WrapPoint::new(wrap_row, 0))
.unwrap_or(self.wrap_snapshot.max_point().row() + WrapRow(1));
let mut cursor = self.transforms.cursor::<Dimensions<WrapRow, BlockRow>>(());
cursor.seek(&start_wrap_row, Bias::Left);
while let Some(transform) = cursor.item() {
if cursor.start().0 > end_wrap_row {
break;
}
if let Some(BlockId::Custom(id)) = transform.block.as_ref().map(|block| block.id())
&& id == block_id
{
return Some(cursor.start().1);
}
cursor.next();
}
None
}
}
pub(crate) fn balancing_block(
my_block: &BlockProperties<Anchor>,
my_snapshot: &MultiBufferSnapshot,
their_snapshot: &MultiBufferSnapshot,
my_display_map_id: EntityId,
companion: &Companion,
) -> Option<BlockProperties<Anchor>> {
let my_anchor = my_block.placement.start();
let my_point = my_anchor.to_point(&my_snapshot);
let their_range = companion.convert_point_to_companion(
my_display_map_id,
my_snapshot,
their_snapshot,
my_point,
);
let their_anchor = their_snapshot.anchor_at(their_range.start, my_anchor.bias());
let their_placement = match my_block.placement {
BlockPlacement::Above(_) => BlockPlacement::Above(their_anchor),
BlockPlacement::Below(_) => {
if their_range.is_empty() {
BlockPlacement::Above(their_anchor)
} else {
BlockPlacement::Below(their_anchor)
}
}
// Not supported for balancing
BlockPlacement::Near(_) | BlockPlacement::Replace(_) => return None,
};
Some(BlockProperties {
placement: their_placement,
height: my_block.height,
style: BlockStyle::Spacer,
render: Arc::new(move |cx| {
crate::EditorElement::render_spacer_block(
cx.block_id,
cx.height,
cx.line_height,
cx.indent_guide_padding,
cx.window,
cx.app,
)
}),
priority: my_block.priority,
})
}
impl BlockMapWriterCompanion<'_> {
fn companion_view(&self) -> CompanionView<'_> {
static EMPTY_PATCH: Patch<WrapRow> = Patch::empty();
CompanionView {
display_map_id: self.display_map_id,
companion_wrap_snapshot: &self.companion_wrap_snapshot,
companion_wrap_edits: &EMPTY_PATCH,
companion: self.companion,
}
}
}
impl BlockMapWriter<'_> {
#[ztracing::instrument(skip_all)]
pub fn insert(
&mut self,
blocks: impl IntoIterator<Item = BlockProperties<Anchor>>,
) -> Vec<CustomBlockId> {
let blocks = blocks.into_iter();
let mut ids = Vec::with_capacity(blocks.size_hint().1.unwrap_or(0));
let mut edits = Patch::default();
let wrap_snapshot = self.block_map.wrap_snapshot.borrow().clone();
let buffer = wrap_snapshot.buffer_snapshot();
let mut previous_wrap_row_range: Option<Range<WrapRow>> = None;
let mut companion_blocks = Vec::new();
for block in blocks {
if let BlockPlacement::Replace(_) = &block.placement {
debug_assert!(block.height.unwrap() > 0);
}
let id = self.block_map.insert_block_raw(block.clone(), &buffer);
ids.push(id);
let start = block.placement.start().to_point(&buffer);
let end = block.placement.end().to_point(&buffer);
let start_wrap_row = wrap_snapshot
.make_wrap_point(Point::new(start.row, 0), Bias::Left)
.row();
let end_wrap_row = wrap_snapshot
.make_wrap_point(Point::new(end.row, 0), Bias::Left)
.row();
let (start_row, end_row) = {
previous_wrap_row_range.take_if(|range| {
!range.contains(&start_wrap_row) || !range.contains(&end_wrap_row)
});
let range = previous_wrap_row_range.get_or_insert_with(|| {
let start_row =
wrap_snapshot.prev_row_boundary(WrapPoint::new(start_wrap_row, 0));
let end_row = wrap_snapshot
.next_row_boundary(WrapPoint::new(end_wrap_row, 0))
.unwrap_or(wrap_snapshot.max_point().row() + WrapRow(1));
start_row..end_row
});
(range.start, range.end)
};
// Insert a matching custom block in the companion (if any)
if let Some(companion) = &mut self.companion
&& companion.inverse.is_some()
{
companion_blocks.extend(balancing_block(
&block,
&buffer,
companion.companion_wrap_snapshot.buffer(),
companion.display_map_id,
companion.companion,
));
}
edits = edits.compose([Edit {
old: start_row..end_row,
new: start_row..end_row,
}]);
}
self.block_map.sync(
&wrap_snapshot,
edits,
self.companion
.as_ref()
.map(BlockMapWriterCompanion::companion_view),
);
if let Some(companion) = &mut self.companion
&& let Some(inverse) = &mut companion.inverse
{
let companion_ids = inverse.companion_writer.insert(companion_blocks);
companion
.companion
.custom_block_to_balancing_block(companion.display_map_id)
.borrow_mut()
.extend(ids.iter().copied().zip(companion_ids));
}
ids
}
#[ztracing::instrument(skip_all)]
pub fn resize(&mut self, mut heights: HashMap<CustomBlockId, u32>) {
let wrap_snapshot = self.block_map.wrap_snapshot.borrow().clone();
let buffer = wrap_snapshot.buffer_snapshot();
let mut edits = Patch::default();
let mut last_block_buffer_row = None;
let mut companion_heights = HashMap::default();
for block in &mut self.block_map.custom_blocks {
if let Some(new_height) = heights.remove(&block.id) {
if let BlockPlacement::Replace(_) = &block.placement {
debug_assert!(new_height > 0);
}
if block.height != Some(new_height) {
let new_block = CustomBlock {
id: block.id,
placement: block.placement.clone(),
height: Some(new_height),
style: block.style,
render: block.render.clone(),
priority: block.priority,
};
let new_block = Arc::new(new_block);
*block = new_block.clone();
self.block_map
.custom_blocks_by_id
.insert(block.id, new_block);
if let Some(companion) = &self.companion
&& companion.inverse.is_some()
&& let Some(companion_block_id) = companion
.companion
.custom_block_to_balancing_block(companion.display_map_id)
.borrow()
.get(&block.id)
.copied()
{
companion_heights.insert(companion_block_id, new_height);
}
let start_row = block.placement.start().to_point(buffer).row;
let end_row = block.placement.end().to_point(buffer).row;
if last_block_buffer_row != Some(end_row) {
last_block_buffer_row = Some(end_row);
let start_wrap_row = wrap_snapshot
.make_wrap_point(Point::new(start_row, 0), Bias::Left)
.row();
let end_wrap_row = wrap_snapshot
.make_wrap_point(Point::new(end_row, 0), Bias::Left)
.row();
let start =
wrap_snapshot.prev_row_boundary(WrapPoint::new(start_wrap_row, 0));
let end = wrap_snapshot
.next_row_boundary(WrapPoint::new(end_wrap_row, 0))
.unwrap_or(wrap_snapshot.max_point().row() + WrapRow(1));
edits.push(Edit {
old: start..end,
new: start..end,
})
}
}
}
}
self.block_map.sync(
&wrap_snapshot,
edits,
self.companion
.as_ref()
.map(BlockMapWriterCompanion::companion_view),
);
if let Some(companion) = &mut self.companion
&& let Some(inverse) = &mut companion.inverse
{
inverse.companion_writer.resize(companion_heights);
}
}
#[ztracing::instrument(skip_all)]
pub fn remove(&mut self, block_ids: HashSet<CustomBlockId>) {
let wrap_snapshot = &*self.block_map.wrap_snapshot.borrow();
let buffer = wrap_snapshot.buffer_snapshot();
let mut edits = Patch::default();
let mut last_block_buffer_row = None;
let mut previous_wrap_row_range: Option<Range<WrapRow>> = None;
let mut companion_block_ids: HashSet<CustomBlockId> = HashSet::default();
self.block_map.custom_blocks.retain(|block| {
if block_ids.contains(&block.id) {
let start = block.placement.start().to_point(buffer);
let end = block.placement.end().to_point(buffer);
if last_block_buffer_row != Some(end.row) {
last_block_buffer_row = Some(end.row);
let start_wrap_row = wrap_snapshot
.make_wrap_point(Point::new(start.row, 0), Bias::Left)
.row();
let end_wrap_row = wrap_snapshot
.make_wrap_point(Point::new(end.row, 0), Bias::Left)
.row();
let (start_row, end_row) = {
previous_wrap_row_range.take_if(|range| {
!range.contains(&start_wrap_row) || !range.contains(&end_wrap_row)
});
let range = previous_wrap_row_range.get_or_insert_with(|| {
let start_row =
wrap_snapshot.prev_row_boundary(WrapPoint::new(start_wrap_row, 0));
let end_row = wrap_snapshot
.next_row_boundary(WrapPoint::new(end_wrap_row, 0))
.unwrap_or(wrap_snapshot.max_point().row() + WrapRow(1));
start_row..end_row
});
(range.start, range.end)
};
edits.push(Edit {
old: start_row..end_row,
new: start_row..end_row,
})
}
if let Some(companion) = &self.companion
&& companion.inverse.is_some()
{
companion_block_ids.extend(
companion
.companion
.custom_block_to_balancing_block(companion.display_map_id)
.borrow()
.get(&block.id)
.copied(),
);
}
false
} else {
true
}
});
self.block_map
.custom_blocks_by_id
.retain(|id, _| !block_ids.contains(id));
self.block_map.sync(
wrap_snapshot,
edits,
self.companion
.as_ref()
.map(BlockMapWriterCompanion::companion_view),
);
if let Some(companion) = &mut self.companion
&& let Some(inverse) = &mut companion.inverse
{
companion
.companion
.custom_block_to_balancing_block(companion.display_map_id)
.borrow_mut()
.retain(|id, _| !block_ids.contains(&id));
inverse.companion_writer.remove(companion_block_ids);
}
}
#[ztracing::instrument(skip_all)]
pub fn remove_intersecting_replace_blocks(
&mut self,
ranges: impl IntoIterator<Item = Range<MultiBufferOffset>>,
inclusive: bool,
) {
let wrap_snapshot = self.block_map.wrap_snapshot.borrow();
let mut blocks_to_remove = HashSet::default();
for range in ranges {
for block in self.blocks_intersecting_buffer_range(range, inclusive) {
if matches!(block.placement, BlockPlacement::Replace(_)) {
blocks_to_remove.insert(block.id);
}
}
}
drop(wrap_snapshot);
self.remove(blocks_to_remove);
}
pub fn disable_header_for_buffer(&mut self, buffer_id: BufferId) {
self.block_map
.buffers_with_disabled_headers
.insert(buffer_id);
}
#[ztracing::instrument(skip_all)]
pub fn fold_buffers(
&mut self,
buffer_ids: impl IntoIterator<Item = BufferId>,
multi_buffer: &MultiBuffer,
cx: &App,
) {
self.fold_or_unfold_buffers(true, buffer_ids, multi_buffer, cx);
}
#[ztracing::instrument(skip_all)]
pub fn unfold_buffers(
&mut self,
buffer_ids: impl IntoIterator<Item = BufferId>,
multi_buffer: &MultiBuffer,
cx: &App,
) {
self.fold_or_unfold_buffers(false, buffer_ids, multi_buffer, cx);
}
#[ztracing::instrument(skip_all)]
fn fold_or_unfold_buffers(
&mut self,
fold: bool,
buffer_ids: impl IntoIterator<Item = BufferId>,
multi_buffer: &MultiBuffer,
cx: &App,
) {
let multi_buffer_snapshot = multi_buffer.snapshot(cx);
let mut ranges = Vec::new();
let mut companion_buffer_ids = HashSet::default();
for buffer_id in buffer_ids {
if fold {
self.block_map.folded_buffers.insert(buffer_id);
} else {
self.block_map.folded_buffers.remove(&buffer_id);
}
ranges.extend(multi_buffer_snapshot.range_for_buffer(buffer_id));
if let Some(companion) = &self.companion
&& companion.inverse.is_some()
{
if let Some(diff) = multi_buffer_snapshot.diff_for_buffer_id(buffer_id) {
let companion_buffer_id =
if companion.companion.is_rhs(companion.display_map_id) {
diff.base_text().remote_id()
} else {
diff.buffer_id()
};
companion_buffer_ids.insert(companion_buffer_id);
}
}
}
ranges.sort_unstable_by_key(|range| range.start);
let mut edits = Patch::default();
let wrap_snapshot = self.block_map.wrap_snapshot.borrow().clone();
for range in ranges {
let last_edit_row = cmp::min(
wrap_snapshot.make_wrap_point(range.end, Bias::Right).row() + WrapRow(1),
wrap_snapshot.max_point().row(),
) + WrapRow(1);
let range = wrap_snapshot.make_wrap_point(range.start, Bias::Left).row()..last_edit_row;
edits.push(Edit {
old: range.clone(),
new: range,
});
}
self.block_map.sync(
&wrap_snapshot,
edits.clone(),
self.companion
.as_ref()
.map(BlockMapWriterCompanion::companion_view),
);
if let Some(companion) = &mut self.companion
&& let Some(inverse) = &mut companion.inverse
{
inverse.companion_writer.fold_or_unfold_buffers(
fold,
companion_buffer_ids,
inverse.companion_multibuffer,
cx,
);
}
}
#[ztracing::instrument(skip_all)]
fn blocks_intersecting_buffer_range(
&self,
range: Range<MultiBufferOffset>,
inclusive: bool,
) -> &[Arc<CustomBlock>] {
if range.is_empty() && !inclusive {
return &[];
}
let wrap_snapshot = self.block_map.wrap_snapshot.borrow();
let buffer = wrap_snapshot.buffer_snapshot();
let start_block_ix = match self.block_map.custom_blocks.binary_search_by(|block| {
let block_end = block.end().to_offset(buffer);
block_end.cmp(&range.start).then(Ordering::Greater)
}) {
Ok(ix) | Err(ix) => ix,
};
let end_block_ix =
match self.block_map.custom_blocks[start_block_ix..].binary_search_by(|block| {
let block_start = block.start().to_offset(buffer);
block_start.cmp(&range.end).then(if inclusive {
Ordering::Less
} else {
Ordering::Greater
})
}) {
Ok(ix) | Err(ix) => ix,
};
&self.block_map.custom_blocks[start_block_ix..][..end_block_ix]
}
}
impl BlockSnapshot {
#[inline(always)]
pub fn has_replacement_blocks(&self) -> bool {
self.transforms.summary().has_replacement_blocks
}
#[cfg(test)]
#[ztracing::instrument(skip_all)]
pub fn text(&self) -> String {
self.chunks(
BlockRow(0)..self.transforms.summary().output_rows,
LanguageAwareStyling {
tree_sitter: false,
diagnostics: false,
},
false,
Highlights::default(),
)
.map(|chunk| chunk.text)
.collect()
}
#[ztracing::instrument(skip_all)]
pub(crate) fn chunks<'a>(
&'a self,
rows: Range<BlockRow>,
language_aware: LanguageAwareStyling,
masked: bool,
highlights: Highlights<'a>,
) -> BlockChunks<'a> {
let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows);
let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(());
cursor.seek(&rows.start, Bias::Right);
let transform_output_start = cursor.start().0;
let transform_input_start = cursor.start().1;
let mut input_start = transform_input_start;
let mut input_end = transform_input_start;
if let Some(transform) = cursor.item()
&& transform.block.is_none()
{
input_start += rows.start - transform_output_start;
input_end += cmp::min(
rows.end - transform_output_start,
RowDelta(transform.summary.input_rows.0),
);
}
BlockChunks {
input_chunks: self.wrap_snapshot.chunks(
input_start..input_end,
language_aware,
highlights,
),
input_chunk: Default::default(),
transforms: cursor,
output_row: rows.start,
line_count_overflow: RowDelta(0),
max_output_row,
masked,
}
}
#[ztracing::instrument(skip_all)]
pub(super) fn row_infos(&self, start_row: BlockRow) -> BlockRows<'_> {
let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(());
cursor.seek(&start_row, Bias::Right);
let Dimensions(output_start, input_start, _) = cursor.start();
let overshoot = if cursor
.item()
.is_some_and(|transform| transform.block.is_none())
{
start_row - *output_start
} else {
RowDelta(0)
};
let input_start_row = *input_start + overshoot;
BlockRows {
transforms: cursor,
input_rows: self.wrap_snapshot.row_infos(input_start_row),
output_row: start_row,
started: false,
}
}
#[ztracing::instrument(skip_all)]
pub fn blocks_in_range(
&self,
rows: Range<BlockRow>,
) -> impl Iterator<Item = (BlockRow, &Block)> {
let mut cursor = self.transforms.cursor::<BlockRow>(());
cursor.seek(&rows.start, Bias::Left);
while *cursor.start() < rows.start && cursor.end() <= rows.start {
cursor.next();
}
std::iter::from_fn(move || {
while let Some(transform) = cursor.item() {
let start_row = *cursor.start();
if start_row > rows.end
|| (start_row == rows.end
&& transform
.block
.as_ref()
.is_some_and(|block| block.height() > 0))
{
break;
}
if let Some(block) = &transform.block {
cursor.next();
return Some((start_row, block));
} else {
cursor.next();
}
}
None
})
}
#[ztracing::instrument(skip_all)]
pub(crate) fn sticky_header_excerpt(&self, position: f64) -> Option<StickyHeaderExcerpt<'_>> {
let top_row = position as u32;
let mut cursor = self.transforms.cursor::<BlockRow>(());
cursor.seek(&BlockRow(top_row), Bias::Right);
while let Some(transform) = cursor.item() {
match &transform.block {
Some(
Block::ExcerptBoundary { excerpt, .. } | Block::BufferHeader { excerpt, .. },
) => {
return Some(StickyHeaderExcerpt { excerpt });
}
Some(block) if block.is_buffer_header() => return None,
_ => {
cursor.prev();
continue;
}
}
}
None
}
#[ztracing::instrument(skip_all)]
pub fn block_for_id(&self, block_id: BlockId) -> Option<Block> {
let buffer = self.wrap_snapshot.buffer_snapshot();
let wrap_point = match block_id {
BlockId::Custom(custom_block_id) => {
let custom_block = self.custom_blocks_by_id.get(&custom_block_id)?;
return Some(Block::Custom(custom_block.clone()));
}
BlockId::ExcerptBoundary(start_anchor) => {
let start_point = start_anchor.to_point(&buffer);
self.wrap_snapshot.make_wrap_point(start_point, Bias::Left)
}
BlockId::FoldedBuffer(buffer_id) => self.wrap_snapshot.make_wrap_point(
buffer
.anchor_in_excerpt(buffer.excerpts_for_buffer(buffer_id).next()?.context.start)?
.to_point(buffer),
Bias::Left,
),
BlockId::Spacer(_) => return None,
};
let wrap_row = wrap_point.row();
let mut cursor = self.transforms.cursor::<WrapRow>(());
cursor.seek(&wrap_row, Bias::Left);
while let Some(transform) = cursor.item() {
if let Some(block) = transform.block.as_ref() {
if block.id() == block_id {
return Some(block.clone());
}
} else if *cursor.start() > wrap_row {
break;
}
cursor.next();
}
None
}
#[ztracing::instrument(skip_all)]
pub fn max_point(&self) -> BlockPoint {
let row = self
.transforms
.summary()
.output_rows
.saturating_sub(RowDelta(1));
BlockPoint::new(row, self.line_len(row))
}
#[ztracing::instrument(skip_all)]
pub fn longest_row(&self) -> BlockRow {
self.transforms.summary().longest_row
}
#[ztracing::instrument(skip_all)]
pub fn longest_row_in_range(&self, range: Range<BlockRow>) -> BlockRow {
let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(());
cursor.seek(&range.start, Bias::Right);
let mut longest_row = range.start;
let mut longest_row_chars = 0;
if let Some(transform) = cursor.item() {
if transform.block.is_none() {
let &Dimensions(output_start, input_start, _) = cursor.start();
let overshoot = range.start - output_start;
let wrap_start_row = input_start + WrapRow(overshoot.0);
let wrap_end_row = cmp::min(
input_start + WrapRow((range.end - output_start).0),
cursor.end().1,
);
let summary = self
.wrap_snapshot
.text_summary_for_range(wrap_start_row..wrap_end_row);
longest_row = BlockRow(range.start.0 + summary.longest_row);
longest_row_chars = summary.longest_row_chars;
}
cursor.next();
}
let cursor_start_row = cursor.start().0;
if range.end > cursor_start_row {
let summary = cursor.summary::<_, TransformSummary>(&range.end, Bias::Right);
if summary.longest_row_chars > longest_row_chars {
longest_row = cursor_start_row + summary.longest_row;
longest_row_chars = summary.longest_row_chars;
}
if let Some(transform) = cursor.item()
&& transform.block.is_none()
{
let &Dimensions(output_start, input_start, _) = cursor.start();
let overshoot = range.end - output_start;
let wrap_start_row = input_start;
let wrap_end_row = input_start + overshoot;
let summary = self
.wrap_snapshot
.text_summary_for_range(wrap_start_row..wrap_end_row);
if summary.longest_row_chars > longest_row_chars {
longest_row = output_start + RowDelta(summary.longest_row);
}
}
}
longest_row
}
#[ztracing::instrument(skip_all)]
pub(super) fn line_len(&self, row: BlockRow) -> u32 {
let (start, _, item) =
self.transforms
.find::<Dimensions<BlockRow, WrapRow>, _>((), &row, Bias::Right);
if let Some(transform) = item {
let Dimensions(output_start, input_start, _) = start;
let overshoot = row - output_start;
if transform.block.is_some() {
0
} else {
self.wrap_snapshot.line_len(input_start + overshoot)
}
} else if row == BlockRow(0) {
0
} else {
panic!("row out of range");
}
}
#[ztracing::instrument(skip_all)]
pub(super) fn is_block_line(&self, row: BlockRow) -> bool {
let (_, _, item) = self.transforms.find::<BlockRow, _>((), &row, Bias::Right);
item.is_some_and(|t| t.block.is_some())
}
#[ztracing::instrument(skip_all)]
pub(super) fn is_folded_buffer_header(&self, row: BlockRow) -> bool {
let (_, _, item) = self.transforms.find::<BlockRow, _>((), &row, Bias::Right);
let Some(transform) = item else {
return false;
};
matches!(transform.block, Some(Block::FoldedBuffer { .. }))
}
#[ztracing::instrument(skip_all)]
pub(super) fn is_line_replaced(&self, row: MultiBufferRow) -> bool {
let wrap_point = self
.wrap_snapshot
.make_wrap_point(Point::new(row.0, 0), Bias::Left);
let (_, _, item) = self
.transforms
.find::<WrapRow, _>((), &wrap_point.row(), Bias::Right);
item.is_some_and(|transform| {
transform
.block
.as_ref()
.is_some_and(|block| block.is_replacement())
})
}
#[ztracing::instrument(skip_all)]
pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(());
cursor.seek(&BlockRow(point.row), Bias::Right);
let max_input_row = self.transforms.summary().input_rows;
let mut search_left = (bias == Bias::Left && cursor.start().1 > WrapRow(0))
|| cursor.end().1 == max_input_row;
let mut reversed = false;
loop {
if let Some(transform) = cursor.item() {
let Dimensions(output_start_row, input_start_row, _) = cursor.start();
let Dimensions(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);
match transform.block.as_ref() {
Some(block) => {
if block.is_replacement()
&& (((bias == Bias::Left || search_left) && output_start <= point.0)
|| (!search_left && output_start >= point.0))
{
return BlockPoint(output_start);
}
}
None => {
let input_point = if point.row >= output_end_row.0 {
let line_len = self.wrap_snapshot.line_len(input_end_row - RowDelta(1));
self.wrap_snapshot.clip_point(
WrapPoint::new(input_end_row - RowDelta(1), line_len),
bias,
)
} else {
let output_overshoot = point.0.saturating_sub(output_start);
self.wrap_snapshot
.clip_point(WrapPoint(input_start + output_overshoot), bias)
};
if (input_start..input_end).contains(&input_point.0) {
let input_overshoot = input_point.0.saturating_sub(input_start);
return BlockPoint(output_start + input_overshoot);
}
}
}
if search_left {
cursor.prev();
} else {
cursor.next();
}
} else if reversed {
return self.max_point();
} else {
reversed = true;
search_left = !search_left;
cursor.seek(&BlockRow(point.row), Bias::Right);
}
}
}
pub fn block_point_cursor(&self) -> BlockPointCursor<'_> {
BlockPointCursor {
snapshot: self,
cursor: self.transforms.cursor::<Dimensions<WrapRow, BlockRow>>(()),
}
}
#[ztracing::instrument(skip_all)]
pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint {
let (start, _, item) = self.transforms.find::<Dimensions<WrapRow, BlockRow>, _>(
(),
&wrap_point.row(),
Bias::Right,
);
if let Some(transform) = item {
if transform.block.is_some() {
BlockPoint::new(start.1, 0)
} else {
let Dimensions(input_start_row, output_start_row, _) = start;
let input_start = Point::new(input_start_row.0, 0);
let output_start = Point::new(output_start_row.0, 0);
let input_overshoot = wrap_point.0 - input_start;
BlockPoint(output_start + input_overshoot)
}
} else {
self.max_point()
}
}
#[ztracing::instrument(skip_all)]
pub fn to_wrap_point(&self, block_point: BlockPoint, bias: Bias) -> WrapPoint {
let (start, end, item) = self.transforms.find::<Dimensions<BlockRow, WrapRow>, _>(
(),
&BlockRow(block_point.row),
Bias::Right,
);
if let Some(transform) = item {
match transform.block.as_ref() {
Some(block) => {
if block.place_below() {
let wrap_row = start.1 - RowDelta(1);
WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
} else if block.place_above() {
WrapPoint::new(start.1, 0)
} else if bias == Bias::Left {
WrapPoint::new(start.1, 0)
} else {
let wrap_row = end.1 - RowDelta(1);
WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
}
}
None => {
let overshoot = block_point.row() - start.0;
let wrap_row = start.1 + RowDelta(overshoot.0);
WrapPoint::new(wrap_row, block_point.column)
}
}
} else {
self.wrap_snapshot.max_point()
}
}
pub(super) fn replacement_block_input_range(&self, row: WrapRow) -> Option<Range<WrapRow>> {
let (start, end, item) = self.transforms.find::<WrapRow, _>((), &row, Bias::Right);
item?.block.as_ref()?.is_replacement().then_some(start..end)
}
}
impl BlockChunks<'_> {
/// Go to the next transform
#[ztracing::instrument(skip_all)]
fn advance(&mut self) {
self.input_chunk = Chunk::default();
self.transforms.next();
while let Some(transform) = self.transforms.item() {
if transform
.block
.as_ref()
.is_some_and(|block| block.height() == 0)
{
self.transforms.next();
} else {
break;
}
}
if self
.transforms
.item()
.is_some_and(|transform| transform.block.is_none())
{
let start_input_row = self.transforms.start().1;
let start_output_row = self.transforms.start().0;
if start_output_row < self.max_output_row {
let end_input_row = cmp::min(
self.transforms.end().1,
start_input_row + (self.max_output_row - start_output_row),
);
self.input_chunks.seek(start_input_row..end_input_row);
}
}
}
}
pub struct StickyHeaderExcerpt<'a> {
pub excerpt: &'a ExcerptBoundaryInfo,
}
impl<'a> Iterator for BlockChunks<'a> {
type Item = Chunk<'a>;
#[ztracing::instrument(skip_all)]
fn next(&mut self) -> Option<Self::Item> {
if self.output_row >= self.max_output_row {
return None;
}
if self.line_count_overflow > RowDelta(0) {
let lines = self.line_count_overflow.0.min(u128::BITS);
self.line_count_overflow.0 -= lines;
self.output_row += RowDelta(lines);
return Some(Chunk {
text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..lines as usize]) },
chars: 1u128.unbounded_shl(lines).wrapping_sub(1),
..Default::default()
});
}
let transform = self.transforms.item()?;
if transform.block.is_some() {
let block_start = self.transforms.start().0;
let mut block_end = self.transforms.end().0;
self.advance();
if self.transforms.item().is_none() {
block_end -= RowDelta(1);
}
let start_in_block = self.output_row - block_start;
let end_in_block = cmp::min(self.max_output_row, block_end) - block_start;
let line_count = end_in_block - start_in_block;
let lines = RowDelta(line_count.0.min(u128::BITS));
self.line_count_overflow = line_count - lines;
self.output_row += lines;
return Some(Chunk {
text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..lines.0 as usize]) },
chars: 1u128.unbounded_shl(lines.0).wrapping_sub(1),
..Default::default()
});
}
if self.input_chunk.text.is_empty() {
if let Some(input_chunk) = self.input_chunks.next() {
self.input_chunk = input_chunk;
} else {
if self.output_row < self.max_output_row {
self.output_row.0 += 1;
self.advance();
if self.transforms.item().is_some() {
return Some(Chunk {
text: "\n",
chars: 1,
..Default::default()
});
}
}
return None;
}
}
let transform_end = self.transforms.end().0;
let (prefix_rows, prefix_bytes) =
offset_for_row(self.input_chunk.text, transform_end - self.output_row);
self.output_row += prefix_rows;
let (mut prefix, suffix) = self.input_chunk.text.split_at(prefix_bytes);
self.input_chunk.text = suffix;
self.input_chunk.tabs >>= prefix_bytes.saturating_sub(1);
self.input_chunk.chars >>= prefix_bytes.saturating_sub(1);
self.input_chunk.newlines >>= prefix_bytes.saturating_sub(1);
let mut tabs = self.input_chunk.tabs;
let mut chars = self.input_chunk.chars;
let mut newlines = self.input_chunk.newlines;
if self.masked {
// Not great for multibyte text because to keep cursor math correct we
// need to have the same number of chars in the input as output.
let chars_count = prefix.chars().count();
let bullet_len = chars_count;
prefix = unsafe { std::str::from_utf8_unchecked(&BULLETS[..bullet_len]) };
chars = 1u128.unbounded_shl(bullet_len as u32).wrapping_sub(1);
tabs = 0;
newlines = 0;
}
let chunk = Chunk {
text: prefix,
tabs,
chars,
newlines,
..self.input_chunk.clone()
};
if self.output_row == transform_end {
self.advance();
}
Some(chunk)
}
}
impl Iterator for BlockRows<'_> {
type Item = RowInfo;
#[ztracing::instrument(skip_all)]
fn next(&mut self) -> Option<Self::Item> {
if self.started {
self.output_row.0 += 1;
} else {
self.started = true;
}
if self.output_row >= self.transforms.end().0 {
self.transforms.next();
while let Some(transform) = self.transforms.item() {
if transform
.block
.as_ref()
.is_some_and(|block| block.height() == 0)
{
self.transforms.next();
} else {
break;
}
}
let transform = self.transforms.item()?;
if transform
.block
.as_ref()
.is_none_or(|block| block.is_replacement())
{
self.input_rows.seek(self.transforms.start().1);
}
}
let transform = self.transforms.item()?;
if transform.block.as_ref().is_none_or(|block| {
block.is_replacement()
&& self.transforms.start().0 == self.output_row
&& matches!(block, Block::FoldedBuffer { .. }).not()
}) {
self.input_rows.next()
} else {
Some(RowInfo::default())
}
}
}
impl sum_tree::Item for Transform {
type Summary = TransformSummary;
fn summary(&self, _cx: ()) -> Self::Summary {
let mut summary = self.summary.clone();
summary.has_replacement_blocks = self.block.as_ref().is_some_and(Block::is_replacement);
summary
}
}
impl sum_tree::ContextLessSummary for TransformSummary {
fn zero() -> Self {
Default::default()
}
fn add_summary(&mut self, summary: &Self) {
if summary.longest_row_chars > self.longest_row_chars {
self.longest_row = self.output_rows + summary.longest_row;
self.longest_row_chars = summary.longest_row_chars;
}
self.input_rows += summary.input_rows;
self.output_rows += summary.output_rows;
self.has_replacement_blocks |= summary.has_replacement_blocks;
}
}
impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapRow {
fn zero(_cx: ()) -> Self {
Default::default()
}
fn add_summary(&mut self, summary: &'a TransformSummary, _: ()) {
*self += summary.input_rows;
}
}
impl<'a> sum_tree::Dimension<'a, TransformSummary> for BlockRow {
fn zero(_cx: ()) -> Self {
Default::default()
}
fn add_summary(&mut self, summary: &'a TransformSummary, _: ()) {
*self += summary.output_rows;
}
}
impl Deref for BlockContext<'_, '_> {
type Target = App;
fn deref(&self) -> &Self::Target {
self.app
}
}
impl DerefMut for BlockContext<'_, '_> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.app
}
}
impl CustomBlock {
#[ztracing::instrument(skip_all)]
pub fn render(&self, cx: &mut BlockContext) -> AnyElement {
self.render.lock()(cx)
}
#[ztracing::instrument(skip_all)]
pub fn start(&self) -> Anchor {
*self.placement.start()
}
#[ztracing::instrument(skip_all)]
pub fn end(&self) -> Anchor {
*self.placement.end()
}
pub fn style(&self) -> BlockStyle {
self.style
}
pub fn properties(&self) -> BlockProperties<Anchor> {
BlockProperties {
placement: self.placement.clone(),
height: self.height,
style: self.style,
render: Arc::new(|_| {
// Not used
gpui::Empty.into_any_element()
}),
priority: self.priority,
}
}
}
impl Debug for CustomBlock {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Block")
.field("id", &self.id)
.field("placement", &self.placement)
.field("height", &self.height)
.field("style", &self.style)
.field("priority", &self.priority)
.finish_non_exhaustive()
}
}
// Count the number of bytes prior to a target point. If the string doesn't contain the target
// point, return its total extent. Otherwise return the target point itself.
fn offset_for_row(s: &str, target: RowDelta) -> (RowDelta, usize) {
let mut row = 0;
let mut offset = 0;
for (ix, line) in s.split('\n').enumerate() {
if ix > 0 {
row += 1;
offset += 1;
}
if row >= target.0 {
break;
}
offset += line.len();
}
(RowDelta(row), offset)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
display_map::{
Companion, DisplayMap, fold_map::FoldMap, fold_map::FoldPlaceholder,
inlay_map::InlayMap, tab_map::TabMap, wrap_map::WrapMap,
},
test::test_font,
};
use buffer_diff::BufferDiff;
use gpui::{App, AppContext as _, Element, div, font, px};
use itertools::Itertools;
use language::{Buffer, Capability, Point};
use multi_buffer::{MultiBuffer, PathKey};
use project::project_settings::DiagnosticSeverity;
use rand::prelude::*;
use settings::SettingsStore;
use std::env;
use util::RandomCharIter;
#[gpui::test]
fn test_offset_for_row() {
assert_eq!(offset_for_row("", RowDelta(0)), (RowDelta(0), 0));
assert_eq!(offset_for_row("", RowDelta(1)), (RowDelta(0), 0));
assert_eq!(offset_for_row("abcd", RowDelta(0)), (RowDelta(0), 0));
assert_eq!(offset_for_row("abcd", RowDelta(1)), (RowDelta(0), 4));
assert_eq!(offset_for_row("\n", RowDelta(0)), (RowDelta(0), 0));
assert_eq!(offset_for_row("\n", RowDelta(1)), (RowDelta(1), 1));
assert_eq!(
offset_for_row("abc\ndef\nghi", RowDelta(0)),
(RowDelta(0), 0)
);
assert_eq!(
offset_for_row("abc\ndef\nghi", RowDelta(1)),
(RowDelta(1), 4)
);
assert_eq!(
offset_for_row("abc\ndef\nghi", RowDelta(2)),
(RowDelta(2), 8)
);
assert_eq!(
offset_for_row("abc\ndef\nghi", RowDelta(3)),
(RowDelta(2), 11)
);
}
#[gpui::test]
fn test_basic_blocks(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "aaa\nbbb\nccc\nddd";
let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 1.try_into().unwrap());
let (wrap_map, wraps_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
let block_ids = writer.insert(vec![
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 2))),
height: Some(2),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(3, 3))),
height: Some(3),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
]);
let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
let blocks = snapshot
.blocks_in_range(BlockRow(0)..BlockRow(8))
.map(|(start_row, block)| {
let block = block.as_custom().unwrap();
(start_row.0..start_row.0 + block.height.unwrap(), block.id)
})
.collect::<Vec<_>>();
// When multiple blocks are on the same line, the newer blocks appear first.
assert_eq!(
blocks,
&[
(1..2, block_ids[0]),
(2..4, block_ids[1]),
(7..10, block_ids[2]),
]
);
assert_eq!(
snapshot.to_block_point(WrapPoint::new(WrapRow(0), 3)),
BlockPoint::new(BlockRow(0), 3)
);
assert_eq!(
snapshot.to_block_point(WrapPoint::new(WrapRow(1), 0)),
BlockPoint::new(BlockRow(4), 0)
);
assert_eq!(
snapshot.to_block_point(WrapPoint::new(WrapRow(3), 3)),
BlockPoint::new(BlockRow(6), 3)
);
assert_eq!(
snapshot.to_wrap_point(BlockPoint::new(BlockRow(0), 3), Bias::Left),
WrapPoint::new(WrapRow(0), 3)
);
assert_eq!(
snapshot.to_wrap_point(BlockPoint::new(BlockRow(1), 0), Bias::Left),
WrapPoint::new(WrapRow(1), 0)
);
assert_eq!(
snapshot.to_wrap_point(BlockPoint::new(BlockRow(3), 0), Bias::Left),
WrapPoint::new(WrapRow(1), 0)
);
assert_eq!(
snapshot.to_wrap_point(BlockPoint::new(BlockRow(7), 0), Bias::Left),
WrapPoint::new(WrapRow(3), 3)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(1), 0), Bias::Left),
BlockPoint::new(BlockRow(0), 3)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(1), 0), Bias::Right),
BlockPoint::new(BlockRow(4), 0)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(1), 1), Bias::Left),
BlockPoint::new(BlockRow(0), 3)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(1), 1), Bias::Right),
BlockPoint::new(BlockRow(4), 0)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(4), 0), Bias::Left),
BlockPoint::new(BlockRow(4), 0)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(4), 0), Bias::Right),
BlockPoint::new(BlockRow(4), 0)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(6), 3), Bias::Left),
BlockPoint::new(BlockRow(6), 3)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(6), 3), Bias::Right),
BlockPoint::new(BlockRow(6), 3)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(7), 0), Bias::Left),
BlockPoint::new(BlockRow(6), 3)
);
assert_eq!(
snapshot.clip_point(BlockPoint::new(BlockRow(7), 0), Bias::Right),
BlockPoint::new(BlockRow(6), 3)
);
assert_eq!(
snapshot
.row_infos(BlockRow(0))
.map(|row_info| row_info.buffer_row)
.collect::<Vec<_>>(),
&[
Some(0),
None,
None,
None,
Some(1),
Some(2),
Some(3),
None,
None,
None
]
);
// Insert a line break, separating two block decorations into separate lines.
let buffer_snapshot = buffer.update(cx, |buffer, cx| {
buffer.edit([(Point::new(1, 1)..Point::new(1, 1), "!!!\n")], None, cx);
buffer.snapshot(cx)
});
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot, subscription.consume().into_inner());
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, 4.try_into().unwrap());
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
let snapshot = block_map.read(wraps_snapshot, wrap_edits, None);
assert_eq!(snapshot.text(), "aaa\n\nb!!!\n\n\nbb\nccc\nddd\n\n\n");
}
#[gpui::test]
fn test_blocks_hidden_in_folds(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "line0\nline1\nline2\nline3\nline4";
let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let tab_size = 1.try_into().unwrap();
let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, tab_size);
let (wrap_map, wraps_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
let above = |row| BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(row, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
};
let below = |row| BlockProperties {
placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(row, 0))),
..above(row)
};
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
let block_ids = writer.insert(vec![above(1), above(2), below(2), above(4)]);
let (block_a, block_b, block_c, block_d) =
(block_ids[0], block_ids[1], block_ids[2], block_ids[3]);
let present_blocks =
|block_map: &mut BlockMap, wraps_snapshot: WrapSnapshot, wrap_edits: WrapPatch| {
let snapshot = block_map.read(wraps_snapshot, wrap_edits, None);
let max_row = snapshot.max_point().row;
snapshot
.blocks_in_range(BlockRow(0)..BlockRow(max_row + 1))
.filter_map(|(_, block)| Some(block.as_custom()?.id))
.collect::<HashSet<_>>()
};
assert_eq!(
present_blocks(&mut block_map, wraps_snapshot, Default::default()),
HashSet::from_iter([block_a, block_b, block_c, block_d]),
"every block is present before folding",
);
// Fold lines 2 and 3 entirely, leaving line1 (the fold start) visible.
let (inlay_snapshot, inlay_edits) = inlay_map.sync(buffer_snapshot.clone(), vec![]);
let (mut fold_writer, _, _) = fold_map.write(inlay_snapshot, inlay_edits);
let (fold_snapshot, fold_edits) = fold_writer.fold(vec![(
Point::new(1, 5)..Point::new(3, 5),
FoldPlaceholder::test(),
)]);
let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
assert_eq!(
present_blocks(&mut block_map, wraps_snapshot, wrap_edits),
HashSet::from_iter([block_a, block_d]),
"blocks B and C anchored to folded lines are dropped, A (fold-start line) and D (past the fold) stay",
);
}
#[gpui::test]
fn test_multibuffer_headers_and_footers(cx: &mut App) {
init_test(cx);
let buffer1 = cx.new(|cx| Buffer::local("Buffer 1", cx));
let buffer2 = cx.new(|cx| Buffer::local("Buffer 2", cx));
let buffer3 = cx.new(|cx| Buffer::local("Buffer 3", cx));
let multi_buffer = cx.new(|cx| {
let mut multi_buffer = MultiBuffer::new(Capability::ReadWrite);
multi_buffer.set_excerpts_for_path(
PathKey::sorted(0),
buffer1.clone(),
[Point::zero()..buffer1.read(cx).max_point()],
0,
cx,
);
multi_buffer.set_excerpts_for_path(
PathKey::sorted(1),
buffer2.clone(),
[Point::zero()..buffer2.read(cx).max_point()],
0,
cx,
);
multi_buffer.set_excerpts_for_path(
PathKey::sorted(2),
buffer3.clone(),
[Point::zero()..buffer3.read(cx).max_point()],
0,
cx,
);
multi_buffer
});
let excerpt_start_anchors = multi_buffer.read_with(cx, |mb, _| {
let snapshot = mb.snapshot(cx);
snapshot
.excerpts()
.map(|e| snapshot.anchor_in_excerpt(e.context.start).unwrap())
.collect::<Vec<_>>()
});
let font = test_font();
let font_size = px(14.);
let font_id = cx.text_system().resolve_font(&font);
let mut wrap_width = px(0.);
for c in "Buff".chars() {
wrap_width += cx
.text_system()
.advance(font_id, font_size, c)
.unwrap()
.width;
}
let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
let (_, inlay_snapshot) = InlayMap::new(multi_buffer_snapshot);
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let (_, wraps_snapshot) = WrapMap::new(tab_snapshot, font, font_size, Some(wrap_width), cx);
let block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
// Each excerpt has a header above and footer below. Excerpts are also *separated* by a newline.
assert_eq!(snapshot.text(), "\nBuff\ner 1\n\nBuff\ner 2\n\nBuff\ner 3");
let blocks: Vec<_> = snapshot
.blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
.map(|(row, block)| (row.0..row.0 + block.height(), block.id()))
.collect();
assert_eq!(
blocks,
vec![
(0..1, BlockId::ExcerptBoundary(excerpt_start_anchors[0])), // path, header
(3..4, BlockId::ExcerptBoundary(excerpt_start_anchors[1])), // path, header
(6..7, BlockId::ExcerptBoundary(excerpt_start_anchors[2])), // path, header
]
);
}
#[gpui::test]
fn test_replace_with_heights(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "aaa\nbbb\nccc\nddd";
let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let _subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
let (_inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (_fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (_tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 1.try_into().unwrap());
let (_wrap_map, wraps_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
let block_ids = writer.insert(vec![
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 2))),
height: Some(2),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(3, 3))),
height: Some(3),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
]);
{
let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
let mut block_map_writer =
block_map.write(wraps_snapshot.clone(), Default::default(), None);
let mut new_heights = HashMap::default();
new_heights.insert(block_ids[0], 2);
block_map_writer.resize(new_heights);
let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(snapshot.text(), "aaa\n\n\n\n\nbbb\nccc\nddd\n\n\n");
}
{
let mut block_map_writer =
block_map.write(wraps_snapshot.clone(), Default::default(), None);
let mut new_heights = HashMap::default();
new_heights.insert(block_ids[0], 1);
block_map_writer.resize(new_heights);
let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
}
{
let mut block_map_writer =
block_map.write(wraps_snapshot.clone(), Default::default(), None);
let mut new_heights = HashMap::default();
new_heights.insert(block_ids[0], 0);
block_map_writer.resize(new_heights);
let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(snapshot.text(), "aaa\n\n\nbbb\nccc\nddd\n\n\n");
}
{
let mut block_map_writer =
block_map.write(wraps_snapshot.clone(), Default::default(), None);
let mut new_heights = HashMap::default();
new_heights.insert(block_ids[0], 3);
block_map_writer.resize(new_heights);
let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(snapshot.text(), "aaa\n\n\n\n\n\nbbb\nccc\nddd\n\n\n");
}
{
let mut block_map_writer =
block_map.write(wraps_snapshot.clone(), Default::default(), None);
let mut new_heights = HashMap::default();
new_heights.insert(block_ids[0], 3);
block_map_writer.resize(new_heights);
let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
// Same height as before, should remain the same
assert_eq!(snapshot.text(), "aaa\n\n\n\n\n\nbbb\nccc\nddd\n\n\n");
}
}
#[gpui::test]
fn test_blocks_on_wrapped_lines(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "one two three\nfour five six\nseven eight";
let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let (_, wraps_snapshot) = cx.update(|cx| {
WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), Some(px(90.)), cx)
});
let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
writer.insert(vec![
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 12))),
render: Arc::new(|_| div().into_any()),
height: Some(1),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(1, 1))),
render: Arc::new(|_| div().into_any()),
height: Some(1),
priority: 0,
},
]);
// Blocks with an 'above' disposition go above their corresponding buffer line.
// Blocks with a 'below' disposition go below their corresponding buffer line.
let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
assert_eq!(
snapshot.text(),
"one two \nthree\n\nfour five \nsix\n\nseven \neight"
);
}
#[gpui::test]
fn test_insert_and_remove_block_anchored_past_soft_wrap(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "one two three\nfour\nfive";
let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let (_, wraps_snapshot) = cx.update(|cx| {
WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), Some(px(90.)), cx)
});
let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
let block_id = writer.insert(vec![BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(0, 12))),
render: Arc::new(|_| div().into_any()),
height: Some(2),
priority: 0,
}])[0];
let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(snapshot.text(), "\n\none two \nthree\nfour\nfive");
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
writer.remove(HashSet::from_iter([block_id]));
let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
assert_eq!(snapshot.text(), "one two \nthree\nfour\nfive");
}
#[gpui::test]
fn test_replace_lines(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "line1\nline2\nline3\nline4\nline5";
let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
let buffer_subscription = buffer.update(cx, |buffer, _cx| buffer.subscribe());
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
let tab_size = 1.try_into().unwrap();
let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, tab_size);
let (wrap_map, wraps_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
let replace_block_id = writer.insert(vec![BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Replace(
buffer_snapshot.anchor_after(Point::new(1, 3))
..=buffer_snapshot.anchor_before(Point::new(3, 1)),
),
height: Some(4),
render: Arc::new(|_| div().into_any()),
priority: 0,
}])[0];
let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");
let buffer_snapshot = buffer.update(cx, |buffer, cx| {
buffer.edit([(Point::new(2, 0)..Point::new(3, 0), "")], None, cx);
buffer.snapshot(cx)
});
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot, buffer_subscription.consume().into_inner());
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
let blocks_snapshot = block_map.read(wraps_snapshot, wrap_edits, None);
assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");
let buffer_snapshot = buffer.update(cx, |buffer, cx| {
buffer.edit(
[(
Point::new(1, 5)..Point::new(1, 5),
"\nline 2.1\nline2.2\nline 2.3\nline 2.4",
)],
None,
cx,
);
buffer.snapshot(cx)
});
let (inlay_snapshot, inlay_edits) = inlay_map.sync(
buffer_snapshot.clone(),
buffer_subscription.consume().into_inner(),
);
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None);
assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");
// Blocks inserted right above the start or right below the end of the replaced region are hidden.
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
writer.insert(vec![
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(0, 3))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 3))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(6, 2))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
]);
let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(blocks_snapshot.text(), "\nline1\n\n\n\n\nline5");
// Ensure blocks inserted *inside* replaced region are hidden.
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
writer.insert(vec![
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(1, 3))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(2, 1))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(6, 1))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
]);
let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(blocks_snapshot.text(), "\nline1\n\n\n\n\nline5");
// Removing the replace block shows all the hidden blocks again.
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
writer.remove(HashSet::from_iter([replace_block_id]));
let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
assert_eq!(
blocks_snapshot.text(),
"\nline1\n\nline2\n\n\nline 2.1\nline2.2\nline 2.3\nline 2.4\n\nline4\n\nline5"
);
}
#[gpui::test]
fn test_custom_blocks_inside_buffer_folds(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "111\n\n222\n\n333\n\n444\n\n555\n\n666";
let buffer = cx.update(|cx| {
let multibuffer = MultiBuffer::build_multi(
[
(text, vec![Point::new(0, 0)..Point::new(0, 3)]),
(
text,
vec![
Point::new(2, 0)..Point::new(2, 3),
Point::new(4, 0)..Point::new(4, 3),
Point::new(6, 0)..Point::new(6, 3),
],
),
(
text,
vec![
Point::new(8, 0)..Point::new(8, 3),
Point::new(10, 0)..Point::new(10, 3),
],
),
],
cx,
);
assert_eq!(multibuffer.read(cx).snapshot(cx).excerpts().count(), 6);
multibuffer
});
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let buffer_ids = buffer_snapshot
.excerpts()
.map(|excerpt| excerpt.context.start.buffer_id)
.dedup()
.collect::<Vec<_>>();
assert_eq!(buffer_ids.len(), 3);
let buffer_id_1 = buffer_ids[0];
let buffer_id_2 = buffer_ids[1];
let buffer_id_3 = buffer_ids[2];
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let (_, wrap_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wrap_snapshot.clone(), 2, 1);
let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
assert_eq!(
blocks_snapshot.text(),
"\n\n111\n\n\n222\n\n333\n\n444\n\n\n555\n\n666"
);
assert_eq!(
blocks_snapshot
.row_infos(BlockRow(0))
.map(|i| i.buffer_row)
.collect::<Vec<_>>(),
vec![
None,
None,
Some(0),
None,
None,
Some(2),
None,
Some(4),
None,
Some(6),
None,
None,
Some(8),
None,
Some(10),
]
);
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
let excerpt_blocks_2 = writer.insert(vec![
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(2, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(3, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
]);
let excerpt_blocks_3 = writer.insert(vec![
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(4, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(5, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
},
]);
let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
assert_eq!(
blocks_snapshot.text(),
"\n\n111\n\n\n\n222\n\n\n333\n\n444\n\n\n\n\n555\n\n666\n"
);
assert_eq!(
blocks_snapshot
.row_infos(BlockRow(0))
.map(|i| i.buffer_row)
.collect::<Vec<_>>(),
vec![
None,
None,
Some(0),
None,
None,
None,
Some(2),
None,
None,
Some(4),
None,
Some(6),
None,
None,
None,
None,
Some(8),
None,
Some(10),
None,
]
);
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
buffer.read_with(cx, |buffer, cx| {
writer.fold_buffers([buffer_id_1], buffer, cx);
});
let excerpt_blocks_1 = writer.insert(vec![BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(0, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
}]);
let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
let blocks = blocks_snapshot
.blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
.collect::<Vec<_>>();
for (_, block) in &blocks {
if let BlockId::Custom(custom_block_id) = block.id() {
assert!(
!excerpt_blocks_1.contains(&custom_block_id),
"Should have no blocks from the folded buffer"
);
assert!(
excerpt_blocks_2.contains(&custom_block_id)
|| excerpt_blocks_3.contains(&custom_block_id),
"Should have only blocks from unfolded buffers"
);
}
}
assert_eq!(
1,
blocks
.iter()
.filter(|(_, block)| matches!(block, Block::FoldedBuffer { .. }))
.count(),
"Should have one folded block, producing a header of the second buffer"
);
assert_eq!(
blocks_snapshot.text(),
"\n\n\n\n\n222\n\n\n333\n\n444\n\n\n\n\n555\n\n666\n"
);
assert_eq!(
blocks_snapshot
.row_infos(BlockRow(0))
.map(|i| i.buffer_row)
.collect::<Vec<_>>(),
vec![
None,
None,
None,
None,
None,
Some(2),
None,
None,
Some(4),
None,
Some(6),
None,
None,
None,
None,
Some(8),
None,
Some(10),
None,
]
);
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
buffer.read_with(cx, |buffer, cx| {
writer.fold_buffers([buffer_id_2], buffer, cx);
});
let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
let blocks = blocks_snapshot
.blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
.collect::<Vec<_>>();
for (_, block) in &blocks {
if let BlockId::Custom(custom_block_id) = block.id() {
assert!(
!excerpt_blocks_1.contains(&custom_block_id),
"Should have no blocks from the folded buffer_1"
);
assert!(
!excerpt_blocks_2.contains(&custom_block_id),
"Should have no blocks from the folded buffer_2"
);
assert!(
excerpt_blocks_3.contains(&custom_block_id),
"Should have only blocks from unfolded buffers"
);
}
}
assert_eq!(
2,
blocks
.iter()
.filter(|(_, block)| matches!(block, Block::FoldedBuffer { .. }))
.count(),
"Should have two folded blocks, producing headers"
);
assert_eq!(blocks_snapshot.text(), "\n\n\n\n\n\n\n555\n\n666\n");
assert_eq!(
blocks_snapshot
.row_infos(BlockRow(0))
.map(|i| i.buffer_row)
.collect::<Vec<_>>(),
vec![
None,
None,
None,
None,
None,
None,
None,
Some(8),
None,
Some(10),
None,
]
);
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
buffer.read_with(cx, |buffer, cx| {
writer.unfold_buffers([buffer_id_1], buffer, cx);
});
let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
let blocks = blocks_snapshot
.blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
.collect::<Vec<_>>();
for (_, block) in &blocks {
if let BlockId::Custom(custom_block_id) = block.id() {
assert!(
!excerpt_blocks_2.contains(&custom_block_id),
"Should have no blocks from the folded buffer_2"
);
assert!(
excerpt_blocks_1.contains(&custom_block_id)
|| excerpt_blocks_3.contains(&custom_block_id),
"Should have only blocks from unfolded buffers"
);
}
}
assert_eq!(
1,
blocks
.iter()
.filter(|(_, block)| matches!(block, Block::FoldedBuffer { .. }))
.count(),
"Should be back to a single folded buffer, producing a header for buffer_2"
);
assert_eq!(
blocks_snapshot.text(),
"\n\n\n111\n\n\n\n\n\n555\n\n666\n",
"Should have extra newline for 111 buffer, due to a new block added when it was folded"
);
assert_eq!(
blocks_snapshot
.row_infos(BlockRow(0))
.map(|i| i.buffer_row)
.collect::<Vec<_>>(),
vec![
None,
None,
None,
Some(0),
None,
None,
None,
None,
None,
Some(8),
None,
Some(10),
None,
]
);
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
buffer.read_with(cx, |buffer, cx| {
writer.fold_buffers([buffer_id_3], buffer, cx);
});
let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
let blocks = blocks_snapshot
.blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
.collect::<Vec<_>>();
for (_, block) in &blocks {
if let BlockId::Custom(custom_block_id) = block.id() {
assert!(
excerpt_blocks_1.contains(&custom_block_id),
"Should have no blocks from the folded buffer_1"
);
assert!(
!excerpt_blocks_2.contains(&custom_block_id),
"Should have only blocks from unfolded buffers"
);
assert!(
!excerpt_blocks_3.contains(&custom_block_id),
"Should have only blocks from unfolded buffers"
);
}
}
assert_eq!(
blocks_snapshot.text(),
"\n\n\n111\n\n\n\n",
"Should have a single, first buffer left after folding"
);
assert_eq!(
blocks_snapshot
.row_infos(BlockRow(0))
.map(|i| i.buffer_row)
.collect::<Vec<_>>(),
vec![None, None, None, Some(0), None, None, None, None,]
);
}
#[gpui::test]
fn test_basic_buffer_fold(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "111";
let buffer = cx.update(|cx| {
MultiBuffer::build_multi([(text, vec![Point::new(0, 0)..Point::new(0, 3)])], cx)
});
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let buffer_ids = buffer_snapshot
.excerpts()
.map(|excerpt| excerpt.context.start.buffer_id)
.dedup()
.collect::<Vec<_>>();
assert_eq!(buffer_ids.len(), 1);
let buffer_id = buffer_ids[0];
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());
let (_, wrap_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wrap_snapshot.clone(), 2, 1);
let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
assert_eq!(blocks_snapshot.text(), "\n\n111");
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
buffer.read_with(cx, |buffer, cx| {
writer.fold_buffers([buffer_id], buffer, cx);
});
let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
let blocks = blocks_snapshot
.blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
.collect::<Vec<_>>();
assert_eq!(
1,
blocks
.iter()
.filter(|(_, block)| { matches!(block, Block::FoldedBuffer { .. }) })
.count(),
"Should have one folded block, producing a header of the second buffer"
);
assert_eq!(blocks_snapshot.text(), "\n");
assert_eq!(
blocks_snapshot
.row_infos(BlockRow(0))
.map(|i| i.buffer_row)
.collect::<Vec<_>>(),
vec![None, None],
"When fully folded, should be no buffer rows"
);
}
#[gpui::test(iterations = 60)]
fn test_random_blocks(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
cx.update(init_test);
let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
.unwrap_or(10);
let wrap_width = if rng.random_bool(0.2) {
None
} else {
Some(px(rng.random_range(0.0..=100.0)))
};
let tab_size = 1.try_into().unwrap();
let font_size = px(14.0);
let buffer_start_header_height = rng.random_range(1..=5);
let excerpt_header_height = rng.random_range(1..=5);
log::info!("Wrap width: {:?}", wrap_width);
log::info!("Excerpt Header Height: {:?}", excerpt_header_height);
let is_singleton = rng.random();
let buffer = if is_singleton {
let len = rng.random_range(0..10);
let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
log::info!("initial singleton buffer text: {:?}", text);
cx.update(|cx| MultiBuffer::build_simple(&text, cx))
} else {
cx.update(|cx| {
let multibuffer = MultiBuffer::build_random(&mut rng, cx);
log::info!(
"initial multi-buffer text: {:?}",
multibuffer.read(cx).read(cx).text()
);
multibuffer
})
};
let mut buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let font = test_font();
let (wrap_map, wraps_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font, font_size, wrap_width, cx));
let mut block_map = BlockMap::new(
wraps_snapshot,
buffer_start_header_height,
excerpt_header_height,
);
for _ in 0..operations {
let mut buffer_edits = Vec::new();
match rng.random_range(0..=100) {
0..=19 => {
let wrap_width = if rng.random_bool(0.2) {
None
} else {
Some(px(rng.random_range(0.0..=100.0)))
};
log::info!("Setting wrap width to {:?}", wrap_width);
wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
}
20..=39 => {
let block_count = rng.random_range(1..=5);
let block_properties = (0..block_count)
.map(|_| {
let buffer = cx.update(|cx| buffer.read(cx).read(cx).clone());
let offset = buffer.clip_offset(
rng.random_range(MultiBufferOffset(0)..=buffer.len()),
Bias::Left,
);
let mut min_height = 0;
let placement = match rng.random_range(0..3) {
0 => {
min_height = 1;
let start = buffer.anchor_after(offset);
let end = buffer.anchor_after(buffer.clip_offset(
rng.random_range(offset..=buffer.len()),
Bias::Left,
));
BlockPlacement::Replace(start..=end)
}
1 => BlockPlacement::Above(buffer.anchor_after(offset)),
_ => BlockPlacement::Below(buffer.anchor_after(offset)),
};
let height = rng.random_range(min_height..512);
BlockProperties {
style: BlockStyle::Fixed,
placement,
height: Some(height),
render: Arc::new(|_| div().into_any()),
priority: 0,
}
})
.collect::<Vec<_>>();
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot.clone(), vec![]);
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
let block_ids =
block_map.insert(block_properties.iter().map(|props| BlockProperties {
placement: props.placement.clone(),
height: props.height,
style: props.style,
render: Arc::new(|_| div().into_any()),
priority: 0,
}));
for (block_properties, block_id) in block_properties.iter().zip(block_ids) {
log::info!(
"inserted block {:?} with height {:?} and id {:?}",
block_properties
.placement
.as_ref()
.map(|p| p.to_point(&buffer_snapshot)),
block_properties.height,
block_id
);
}
}
40..=59 if !block_map.custom_blocks.is_empty() => {
let block_count = rng.random_range(1..=4.min(block_map.custom_blocks.len()));
let block_ids_to_remove = block_map
.custom_blocks
.choose_multiple(&mut rng, block_count)
.map(|block| block.id)
.collect::<HashSet<_>>();
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot.clone(), vec![]);
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
log::info!(
"removing {} blocks: {:?}",
block_ids_to_remove.len(),
block_ids_to_remove
);
block_map.remove(block_ids_to_remove);
}
60..=79 => {
if buffer.read_with(cx, |buffer, _| buffer.is_singleton()) {
log::info!("Noop fold/unfold operation on a singleton buffer");
continue;
}
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot.clone(), vec![]);
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
let folded_buffers: Vec<_> =
block_map.block_map.folded_buffers.iter().cloned().collect();
let mut unfolded_buffers = buffer_snapshot
.buffer_ids_for_range(Anchor::Min..Anchor::Max)
.collect::<Vec<_>>();
unfolded_buffers.dedup();
log::debug!("All buffers {unfolded_buffers:?}");
log::debug!("Folded buffers {folded_buffers:?}");
unfolded_buffers.retain(|buffer_id| {
!block_map.block_map.folded_buffers.contains(buffer_id)
});
let mut folded_count = folded_buffers.len();
let mut unfolded_count = unfolded_buffers.len();
let fold = !unfolded_buffers.is_empty() && rng.random_bool(0.5);
let unfold = !folded_buffers.is_empty() && rng.random_bool(0.5);
if !fold && !unfold {
log::info!(
"Noop fold/unfold operation. Unfolded buffers: {unfolded_count}, folded buffers: {folded_count}"
);
continue;
}
buffer.update(cx, |buffer, cx| {
if fold {
let buffer_to_fold =
unfolded_buffers[rng.random_range(0..unfolded_buffers.len())];
log::info!("Folding {buffer_to_fold:?}");
let related_excerpts = buffer_snapshot
.excerpts()
.filter_map(|excerpt| {
if excerpt.context.start.buffer_id == buffer_to_fold {
Some((
excerpt.context.start,
buffer_snapshot
.buffer_for_id(buffer_to_fold)
.unwrap()
.text_for_range(excerpt.context)
.collect::<String>(),
))
} else {
None
}
})
.collect::<Vec<_>>();
log::info!(
"Folding {buffer_to_fold:?}, related excerpts: {related_excerpts:?}"
);
folded_count += 1;
unfolded_count -= 1;
block_map.fold_buffers([buffer_to_fold], buffer, cx);
}
if unfold {
let buffer_to_unfold =
folded_buffers[rng.random_range(0..folded_buffers.len())];
log::info!("Unfolding {buffer_to_unfold:?}");
unfolded_count += 1;
folded_count -= 1;
block_map.unfold_buffers([buffer_to_unfold], buffer, cx);
}
log::info!(
"Unfolded buffers: {unfolded_count}, folded buffers: {folded_count}"
);
});
}
_ => {
buffer.update(cx, |buffer, cx| {
let mutation_count = rng.random_range(1..=5);
let subscription = buffer.subscribe();
buffer.randomly_mutate(&mut rng, mutation_count, cx);
buffer_snapshot = buffer.snapshot(cx);
buffer_edits.extend(subscription.consume());
log::info!("buffer text: {:?}", buffer_snapshot.text());
});
}
}
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None);
assert_eq!(
blocks_snapshot.transforms.summary().input_rows,
wraps_snapshot.max_point().row() + RowDelta(1)
);
log::info!("wrapped text: {:?}", wraps_snapshot.text());
log::info!("blocks text: {:?}", blocks_snapshot.text());
let mut expected_blocks = Vec::new();
expected_blocks.extend(block_map.custom_blocks.iter().filter_map(|block| {
Some((
block.placement.to_wrap_row(&wraps_snapshot)?,
Block::Custom(block.clone()),
))
}));
let mut inlay_point_cursor = wraps_snapshot.inlay_point_cursor();
let mut tab_point_cursor = wraps_snapshot.tab_point_cursor();
let mut fold_point_cursor = wraps_snapshot.fold_point_cursor();
let mut wrap_point_cursor = wraps_snapshot.wrap_point_cursor();
// Note that this needs to be synced with the related section in BlockMap::sync
expected_blocks.extend(block_map.header_and_footer_blocks(
&buffer_snapshot,
MultiBufferOffset(0)..,
|point, bias| {
wrap_point_cursor
.map(
tab_point_cursor.map(
fold_point_cursor.map(inlay_point_cursor.map(point, bias), bias),
),
)
.row()
},
));
BlockMap::sort_blocks(&mut expected_blocks);
for (placement, block) in &expected_blocks {
log::info!(
"Block {:?} placement: {:?} Height: {:?}",
block.id(),
placement,
block.height()
);
}
let mut sorted_blocks_iter = expected_blocks.into_iter().peekable();
let input_buffer_rows = buffer_snapshot
.row_infos(MultiBufferRow(0))
.map(|row| row.buffer_row)
.collect::<Vec<_>>();
let mut expected_buffer_rows = Vec::new();
let mut expected_text = String::new();
let mut expected_block_positions = Vec::new();
let mut expected_replaced_buffer_rows = HashSet::default();
let input_text = wraps_snapshot.text();
// Loop over the input lines, creating (N - 1) empty lines for
// blocks of height N.
//
// It's important to note that output *starts* as one empty line,
// so we special case row 0 to assume a leading '\n'.
//
// Linehood is the birthright of strings.
let input_text_lines = input_text.split('\n').enumerate().peekable();
let mut block_row = 0;
for (wrap_row, input_line) in input_text_lines {
let wrap_row = WrapRow(wrap_row as u32);
let multibuffer_row = wraps_snapshot
.to_point(WrapPoint::new(wrap_row, 0), Bias::Left)
.row;
// Create empty lines for the above block
while let Some((placement, block)) = sorted_blocks_iter.peek() {
if *placement.start() == wrap_row && block.place_above() {
let (_, block) = sorted_blocks_iter.next().unwrap();
expected_block_positions.push((block_row, block.id()));
if block.height() > 0 {
let text = "\n".repeat((block.height() - 1) as usize);
if block_row > 0 {
expected_text.push('\n')
}
expected_text.push_str(&text);
for _ in 0..block.height() {
expected_buffer_rows.push(None);
}
block_row += block.height();
}
} else {
break;
}
}
// Skip lines within replace blocks, then create empty lines for the replace block's height
let mut is_in_replace_block = false;
if let Some((BlockPlacement::Replace(replace_range), block)) =
sorted_blocks_iter.peek()
&& wrap_row >= *replace_range.start()
{
is_in_replace_block = true;
if wrap_row == *replace_range.start() {
if matches!(block, Block::FoldedBuffer { .. }) {
expected_buffer_rows.push(None);
} else {
expected_buffer_rows.push(input_buffer_rows[multibuffer_row as usize]);
}
}
if wrap_row == *replace_range.end() {
expected_block_positions.push((block_row, block.id()));
let text = "\n".repeat((block.height() - 1) as usize);
if block_row > 0 {
expected_text.push('\n');
}
expected_text.push_str(&text);
for _ in 1..block.height() {
expected_buffer_rows.push(None);
}
block_row += block.height();
sorted_blocks_iter.next();
}
}
if is_in_replace_block {
expected_replaced_buffer_rows.insert(MultiBufferRow(multibuffer_row));
} else {
let buffer_row = input_buffer_rows[multibuffer_row as usize];
let soft_wrapped = wraps_snapshot
.to_tab_point(WrapPoint::new(wrap_row, 0))
.column()
> 0;
expected_buffer_rows.push(if soft_wrapped { None } else { buffer_row });
if block_row > 0 {
expected_text.push('\n');
}
expected_text.push_str(input_line);
block_row += 1;
}
while let Some((placement, block)) = sorted_blocks_iter.peek() {
if *placement.end() == wrap_row && block.place_below() {
let (_, block) = sorted_blocks_iter.next().unwrap();
expected_block_positions.push((block_row, block.id()));
if block.height() > 0 {
let text = "\n".repeat((block.height() - 1) as usize);
if block_row > 0 {
expected_text.push('\n')
}
expected_text.push_str(&text);
for _ in 0..block.height() {
expected_buffer_rows.push(None);
}
block_row += block.height();
}
} else {
break;
}
}
}
let expected_lines = expected_text.split('\n').collect::<Vec<_>>();
let expected_row_count = expected_lines.len();
log::info!("expected text: {expected_text:?}");
assert_eq!(
blocks_snapshot.max_point().row + 1,
expected_row_count as u32,
"actual row count != expected row count",
);
assert_eq!(
blocks_snapshot.text(),
expected_text,
"actual text != expected text",
);
for start_row in 0..expected_row_count {
let end_row = rng.random_range(start_row + 1..=expected_row_count);
let mut expected_text = expected_lines[start_row..end_row].join("\n");
if end_row < expected_row_count {
expected_text.push('\n');
}
let actual_text = blocks_snapshot
.chunks(
BlockRow(start_row as u32)..BlockRow(end_row as u32),
LanguageAwareStyling {
tree_sitter: false,
diagnostics: false,
},
false,
Highlights::default(),
)
.map(|chunk| chunk.text)
.collect::<String>();
assert_eq!(
actual_text,
expected_text,
"incorrect text starting row row range {:?}",
start_row..end_row
);
assert_eq!(
blocks_snapshot
.row_infos(BlockRow(start_row as u32))
.map(|row_info| row_info.buffer_row)
.collect::<Vec<_>>(),
&expected_buffer_rows[start_row..],
"incorrect buffer_rows starting at row {:?}",
start_row
);
}
assert_eq!(
blocks_snapshot
.blocks_in_range(BlockRow(0)..BlockRow(expected_row_count as u32))
.map(|(row, block)| (row.0, block.id()))
.collect::<Vec<_>>(),
expected_block_positions,
"invalid blocks_in_range({:?})",
0..expected_row_count
);
for (_, expected_block) in
blocks_snapshot.blocks_in_range(BlockRow(0)..BlockRow(expected_row_count as u32))
{
let actual_block = blocks_snapshot.block_for_id(expected_block.id());
assert_eq!(
actual_block.map(|block| block.id()),
Some(expected_block.id())
);
}
for (block_row, block_id) in expected_block_positions {
if let BlockId::Custom(block_id) = block_id {
assert_eq!(
blocks_snapshot.row_for_block(block_id),
Some(BlockRow(block_row))
);
}
}
let mut expected_longest_rows = Vec::new();
let mut longest_line_len = -1_isize;
for (row, line) in expected_lines.iter().enumerate() {
let row = row as u32;
assert_eq!(
blocks_snapshot.line_len(BlockRow(row)),
line.len() as u32,
"invalid line len for row {}",
row
);
let line_char_count = line.chars().count() as isize;
match line_char_count.cmp(&longest_line_len) {
Ordering::Less => {}
Ordering::Equal => expected_longest_rows.push(row),
Ordering::Greater => {
longest_line_len = line_char_count;
expected_longest_rows.clear();
expected_longest_rows.push(row);
}
}
}
let longest_row = blocks_snapshot.longest_row();
assert!(
expected_longest_rows.contains(&longest_row.0),
"incorrect longest row {}. expected {:?} with length {}",
longest_row.0,
expected_longest_rows,
longest_line_len,
);
for _ in 0..10 {
let end_row = rng.random_range(1..=expected_lines.len());
let start_row = rng.random_range(0..end_row);
let mut expected_longest_rows_in_range = vec![];
let mut longest_line_len_in_range = 0;
for (row, line) in (start_row as u32..).zip(&expected_lines[start_row..end_row]) {
let line_char_count = line.chars().count() as isize;
match line_char_count.cmp(&longest_line_len_in_range) {
Ordering::Less => {}
Ordering::Equal => expected_longest_rows_in_range.push(row),
Ordering::Greater => {
longest_line_len_in_range = line_char_count;
expected_longest_rows_in_range.clear();
expected_longest_rows_in_range.push(row);
}
}
}
let longest_row_in_range = blocks_snapshot
.longest_row_in_range(BlockRow(start_row as u32)..BlockRow(end_row as u32));
assert!(
expected_longest_rows_in_range.contains(&longest_row_in_range.0),
"incorrect longest row {} in range {:?}. expected {:?} with length {}",
longest_row.0,
start_row..end_row,
expected_longest_rows_in_range,
longest_line_len_in_range,
);
}
// Ensure that conversion between block points and wrap points is stable.
for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row().0 {
let wrap_point = WrapPoint::new(WrapRow(row), 0);
let block_point = blocks_snapshot.to_block_point(wrap_point);
let left_wrap_point = blocks_snapshot.to_wrap_point(block_point, Bias::Left);
let right_wrap_point = blocks_snapshot.to_wrap_point(block_point, Bias::Right);
assert_eq!(blocks_snapshot.to_block_point(left_wrap_point), block_point);
assert_eq!(
blocks_snapshot.to_block_point(right_wrap_point),
block_point
);
}
let mut block_point = BlockPoint::new(BlockRow(0), 0);
for c in expected_text.chars() {
let left_point = blocks_snapshot.clip_point(block_point, Bias::Left);
let left_buffer_point = blocks_snapshot.to_point(left_point, Bias::Left);
assert_eq!(
blocks_snapshot
.to_block_point(blocks_snapshot.to_wrap_point(left_point, Bias::Left)),
left_point,
"block point: {:?}, wrap point: {:?}",
block_point,
blocks_snapshot.to_wrap_point(left_point, Bias::Left)
);
assert_eq!(
left_buffer_point,
buffer_snapshot.clip_point(left_buffer_point, Bias::Right),
"{:?} is not valid in buffer coordinates",
left_point
);
let right_point = blocks_snapshot.clip_point(block_point, Bias::Right);
let right_buffer_point = blocks_snapshot.to_point(right_point, Bias::Right);
assert_eq!(
blocks_snapshot
.to_block_point(blocks_snapshot.to_wrap_point(right_point, Bias::Right)),
right_point,
"block point: {:?}, wrap point: {:?}",
block_point,
blocks_snapshot.to_wrap_point(right_point, Bias::Right)
);
assert_eq!(
right_buffer_point,
buffer_snapshot.clip_point(right_buffer_point, Bias::Left),
"{:?} is not valid in buffer coordinates",
right_point
);
if c == '\n' {
block_point.0 += Point::new(1, 0);
} else {
block_point.column += c.len_utf8() as u32;
}
}
for buffer_row in 0..=buffer_snapshot.max_point().row {
let buffer_row = MultiBufferRow(buffer_row);
assert_eq!(
blocks_snapshot.is_line_replaced(buffer_row),
expected_replaced_buffer_rows.contains(&buffer_row),
"incorrect is_line_replaced({buffer_row:?}), expected replaced rows: {expected_replaced_buffer_rows:?}",
);
}
}
}
/// Deterministic demonstration of the root cause behind ZED-7G6's crash
/// family: multibuffer anchor comparison is not stable across diff base
/// text changes, which unsorts the fold map's persistent fold tree.
///
/// Folds inside an expanded deleted hunk anchor at the same buffer
/// position and are ordered only by their `diff_base_anchor`s into the
/// diff's base text. When anchor comparison filtered those on
/// *validity*, a base text change that deleted the region one anchor
/// pointed into made comparison fall back to the text anchor's bias —
/// opposite to the answer it gave when the folds were inserted — so the
/// persistent tree was unsorted without having been touched. Sync then
/// walked it with forward-only cursors, emitting edits that misdescribed
/// the change, and the block map kept stale headers for rows that did
/// change.
///
/// Fixed by filtering diff base anchors on *resolvability* against the
/// current base buffer instead (monotone: buffer ids never change and
/// versions only grow), so anchors into deleted base text keep comparing
/// positionally through their tombstones and the answer never flips.
#[gpui::test]
async fn test_folds_stay_sorted_when_diff_base_text_replaced(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "bbb\nccc\nddd\n";
let base_text = "DEL1\nDEL2\nbbb\nccc\nddd\n";
let buffer = cx.new(|cx| Buffer::local(text, cx));
let buffer_text_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
let diff =
cx.new(|cx| BufferDiff::new_with_base_text(base_text, &buffer_text_snapshot, cx));
let multibuffer = cx.new(|cx| {
let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
multibuffer.set_all_diff_hunks_expanded(cx);
multibuffer
});
multibuffer.update(cx, |multibuffer, cx| {
let max_point = buffer.read(cx).max_point();
multibuffer.set_excerpts_for_buffer(buffer.clone(), [Point::zero()..max_point], 0, cx);
multibuffer.add_diff(diff.clone(), cx);
});
cx.run_until_parked();
let subscription = multibuffer.update(cx, |multibuffer, _| multibuffer.subscribe());
let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
assert_eq!(
snapshot.text(),
"DEL1\nDEL2\nbbb\nccc\nddd\n",
"expected the deleted hunk's rows to be materialized at the top"
);
let (mut inlay_map, inlay_snapshot) = InlayMap::new(snapshot.clone());
let (mut fold_map, _) = FoldMap::new(inlay_snapshot.clone());
// Two folds inside the deleted hunk share a buffer position and are
// ordered only by their anchors into the diff's base text: a narrow
// fold within "DEL1", then a wider fold from "DEL2" into the
// buffer's own content.
let (mut writer, ..) = fold_map.write(inlay_snapshot, Vec::new());
let (fold_snapshot, _) = writer.fold(vec![
(Point::new(0, 1)..Point::new(1, 0), FoldPlaceholder::test()),
(Point::new(1, 1)..Point::new(2, 2), FoldPlaceholder::test()),
]);
assert_eq!(
fold_snapshot.fold_count(),
2,
"both folds should anchor inside the expanded deleted hunk"
);
// Keep "DEL1" (the first fold's base anchors stay visible) but
// delete "DEL2" (the second fold's start anchor becomes a tombstone).
// The folds' relative order must survive this: comparison that
// filtered out the tombstoned anchor fell back to the text anchor's
// bias and reversed it.
let new_base_text = "DEL1\nbbb\nccc\nddd\n";
diff.update(cx, |diff, cx| {
diff.set_base_text(Some(new_base_text.into()), buffer_text_snapshot.clone(), cx)
})
.await;
cx.run_until_parked();
let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
let edits = subscription.consume().into_inner();
let (inlay_snapshot, inlay_edits) = inlay_map.sync(snapshot, edits);
// `read` checks that the fold tree is still sorted. An unsorted tree
// makes subsequent syncs emit edits that misdescribe the actual
// changes, which is what leaves block map headers stale in
// production.
fold_map.read(inlay_snapshot, inlay_edits);
}
/// Regression fuzz for ZED-7G6 ("buffer snapshot not found for excerpt
/// boundary"): header blocks cache an `ExcerptBoundaryInfo`, so when a
/// buffer leaves the multibuffer without the block map re-syncing the
/// header's rows, the stale block panics at render time. Excerpt removal
/// is fuzzed together with diffs, folded buffers, text folds, and inlays,
/// because the crash fires in diff-backed multibuffers like the project
/// diff.
///
/// Deeper settings have found real bugs; run them locally when touching
/// this area, e.g. `ITERATIONS=1000 OPERATIONS=40`. Found so far:
/// `InlayMap::sync` panicking on inlays whose anchors predate a path key
/// reuse (minimized into `inlay_map`'s
/// `test_sync_after_path_key_reused_for_different_buffer`), a
/// `FoldMap` canonical-form violation ("found adjacent isomorphic
/// transforms", `SEED=612 OPERATIONS=40`), and the fold tree going out of
/// order (`SEED=144 OPERATIONS=50`): with all diff hunks expanded, fold
/// anchors carry diff base anchors, and replacing a diff's base text
/// changes how those anchors compare, unsorting the persistent fold tree
/// that `FoldMap` seeks through. During the investigation, disabling
/// the fold and wrap maps' test-only invariants the way production
/// builds run let the unsorted tree propagate: `FoldMap::sync` panicked
/// with "cannot seek backward" (`SEED=332 OPERATIONS=60`), matching a
/// large family of open Sentry crashes with that message, and the wrap
/// layer emitted edits that no longer covered the rows that actually
/// changed (`SEED=612 OPERATIONS=50`, caught by
/// `assert_wrap_edits_cover_changes`), which is the mechanism that
/// leaves the block map holding stale header blocks. The inlay panic and
/// the fold tree disorder are fixed by making anchor comparison track
/// resolution; the canonical-form violation is still unfixed.
#[gpui::test(iterations = 20)]
async fn test_random_excerpt_removal_with_diffs(
cx: &mut gpui::TestAppContext,
mut rng: StdRng,
) {
cx.update(init_test);
let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
.unwrap_or(20);
let wrap_width = if rng.random_bool(0.2) {
None
} else {
Some(px(rng.random_range(0.0..=100.0)))
};
let tab_size = 1.try_into().unwrap();
let font_size = px(14.0);
let buffer_start_header_height = rng.random_range(1..=5);
let excerpt_header_height = rng.random_range(1..=5);
log::info!("Wrap width: {wrap_width:?}");
// Half the time, build the multibuffer the way a split diff's left
// hand side does: excerpts of read-only base text buffers, with
// inverted diffs pointing at the main buffers.
let split_style = rng.random_bool(0.5);
let multibuffer;
let mut known_buffers;
let mut diffs = Vec::new();
if split_style {
multibuffer = cx.new(|_cx| MultiBuffer::new(Capability::ReadWrite));
known_buffers = Vec::new();
for _ in 0..rng.random_range(1..=3) {
let text = random_buffer_text(&mut rng);
let main_buffer = cx.new(|cx| Buffer::local(text.clone(), cx));
let base_text = randomized_text(&text, &mut rng);
let diff = cx.new(|cx| {
BufferDiff::new_with_base_text(
&base_text,
&main_buffer.read(cx).text_snapshot(),
cx,
)
});
let base_text_buffer =
diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
multibuffer.update(cx, |multibuffer, cx| {
let max_point = base_text_buffer.read(cx).max_point();
multibuffer.set_excerpts_for_buffer(
base_text_buffer.clone(),
[Point::zero()..max_point],
0,
cx,
);
multibuffer.add_inverted_diff(diff.clone(), main_buffer.clone(), cx);
});
known_buffers.push(base_text_buffer);
diffs.push((diff, main_buffer));
}
} else {
multibuffer = cx.update(|cx| MultiBuffer::build_random(&mut rng, cx));
// Diff views like the project diff show all hunks expanded, which
// materializes deleted rows from base buffers inline.
if rng.random_bool(0.5) {
multibuffer.update(cx, |multibuffer, cx| {
multibuffer.set_all_diff_hunks_expanded(cx);
});
}
known_buffers = multibuffer.read_with(cx, |multibuffer, _| {
multibuffer.all_buffers_iter().collect::<Vec<_>>()
});
// Attach diffs to a random subset of buffers, with base texts that
// differ from the buffer text so that hunks exist.
for buffer in known_buffers.clone() {
if !rng.random_bool(0.5) {
continue;
}
let (base_text, buffer_snapshot) = buffer.read_with(cx, |buffer, _| {
(
randomized_text(&buffer.text(), &mut rng),
buffer.text_snapshot(),
)
});
let diff =
cx.new(|cx| BufferDiff::new_with_base_text(&base_text, &buffer_snapshot, cx));
multibuffer.update(cx, |multibuffer, cx| multibuffer.add_diff(diff.clone(), cx));
diffs.push((diff, buffer));
}
}
let mut buffer_snapshot =
multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let font = test_font();
let (wrap_map, wraps_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font, font_size, wrap_width, cx));
let mut previous_wrap_text = wraps_snapshot.text();
let mut block_map = BlockMap::new(
wraps_snapshot,
buffer_start_header_height,
excerpt_header_height,
);
let subscription = multibuffer.update(cx, |multibuffer, _| multibuffer.subscribe());
let mut next_inlay_id = 0;
let mut operations_until_sync = 0;
for _ in 0..operations {
// Apply several mutations before syncing the display layers, so
// that edit composition across mutations is exercised the way it is
// when more than one change lands between frames.
let sync_now = operations_until_sync == 0;
if sync_now {
operations_until_sync = rng.random_range(1..=4);
}
operations_until_sync -= 1;
match rng.random_range(0..100) {
0..=9 => {
let wrap_width = if rng.random_bool(0.2) {
None
} else {
Some(px(rng.random_range(0.0..=100.0)))
};
log::info!("Setting wrap width to {wrap_width:?}");
wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
}
10..=24 => {
// Folding reads the block map, so bring the display layers
// up to date with any mutations batched since the last sync.
buffer_snapshot =
multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
let pending_edits = subscription.consume().into_inner();
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot.clone(), pending_edits);
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
assert_wrap_edits_cover_changes(
&mut previous_wrap_text,
&wraps_snapshot,
&wrap_edits,
);
let mut writer = block_map.write(wraps_snapshot, wrap_edits, None);
let folded_buffers = writer
.block_map
.folded_buffers
.iter()
.cloned()
.collect::<Vec<_>>();
let mut unfolded_buffers = buffer_snapshot
.buffer_ids_for_range(Anchor::Min..Anchor::Max)
.collect::<Vec<_>>();
unfolded_buffers.dedup();
unfolded_buffers.retain(|buffer_id| !folded_buffers.contains(buffer_id));
multibuffer.read_with(cx, |multibuffer, cx| {
if !unfolded_buffers.is_empty()
&& (folded_buffers.is_empty() || rng.random_bool(0.5))
{
let buffer_to_fold = *unfolded_buffers.choose(&mut rng).unwrap();
log::info!("Folding {buffer_to_fold:?}");
writer.fold_buffers([buffer_to_fold], multibuffer, cx);
} else if !folded_buffers.is_empty() {
let buffer_to_unfold = *folded_buffers.choose(&mut rng).unwrap();
log::info!("Unfolding {buffer_to_unfold:?}");
writer.unfold_buffers([buffer_to_unfold], multibuffer, cx);
}
});
}
// Remove all excerpts for a buffer, as happens when a file
// leaves the project diff.
25..=44 => {
let buffer_ids = multibuffer.read_with(cx, |multibuffer, cx| {
multibuffer
.snapshot(cx)
.all_buffer_ids()
.collect::<Vec<_>>()
});
if buffer_ids.is_empty() {
continue;
}
let buffer_id = *buffer_ids.choose(&mut rng).unwrap();
log::info!("Removing excerpts for buffer {buffer_id:?}");
multibuffer.update(cx, |multibuffer, cx| {
multibuffer.remove_excerpts_for_buffer(buffer_id, cx);
});
}
// Add excerpts for a buffer that currently has none, as
// happens when a file (re-)enters the project diff.
45..=59 => {
let present = multibuffer.read_with(cx, |multibuffer, cx| {
multibuffer
.snapshot(cx)
.all_buffer_ids()
.collect::<Vec<_>>()
});
let absent = known_buffers
.iter()
.filter(|buffer| {
!present.contains(&buffer.read_with(cx, |buffer, _| buffer.remote_id()))
})
.cloned()
.collect::<Vec<_>>();
let buffer = if absent.is_empty() || rng.random_bool(0.3) {
let text = random_buffer_text(&mut rng);
log::info!("Creating new buffer with text: {text:?}");
let buffer = cx.new(|cx| Buffer::local(text, cx));
known_buffers.push(buffer.clone());
buffer
} else {
absent.choose(&mut rng).unwrap().clone()
};
let max_row =
buffer.read_with(cx, |buffer, _| buffer.snapshot().max_point().row);
let ranges = (0..rng.random_range(1..=3))
.map(|_| {
let start_row = rng.random_range(0..=max_row);
let end_row = rng.random_range(start_row..=max_row);
Point::new(start_row, 0)..Point::new(end_row, 0)
})
.collect::<Vec<_>>();
log::info!("Setting excerpts {ranges:?}");
multibuffer.update(cx, |multibuffer, cx| {
multibuffer.set_excerpts_for_buffer(buffer.clone(), ranges, 0, cx);
// Re-attach the buffer's diff if it has one, like the
// project diff does when a file re-enters.
if let Some((diff, _)) =
diffs.iter().find(|(_, candidate)| *candidate == buffer)
{
multibuffer.add_diff(diff.clone(), cx);
}
});
}
// Change a diff's base text, as happens when the diff base
// changes or HEAD advances.
60..=69 if !diffs.is_empty() => {
let (diff, buffer) = diffs.choose(&mut rng).unwrap().clone();
let new_base_text = diff.read_with(cx, |diff, cx| {
randomized_text(&diff.base_text_string(cx).unwrap_or_default(), &mut rng)
});
let buffer_text_snapshot =
buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
log::info!("Setting diff base text to {new_base_text:?}");
diff.update(cx, |diff, cx| {
diff.set_base_text(Some(new_base_text.into()), buffer_text_snapshot, cx)
})
.await;
cx.run_until_parked();
}
// Fold or unfold random text ranges, so that fold edits are
// propagated through the tab and wrap layers alongside the
// multibuffer mutations. Mutating the inlay and fold maps
// requires them to be current, as `DisplayMap` keeps them, so
// sync the pending mutations through first.
70..=81 => {
buffer_snapshot =
multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
let pending_edits = subscription.consume().into_inner();
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot.clone(), pending_edits);
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
assert_wrap_edits_cover_changes(
&mut previous_wrap_text,
&wraps_snapshot,
&wrap_edits,
);
block_map.read(wraps_snapshot, wrap_edits, None);
if rng.random_bool(0.5) {
for (fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) {
let (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map
.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
assert_wrap_edits_cover_changes(
&mut previous_wrap_text,
&wraps_snapshot,
&wrap_edits,
);
block_map.read(wraps_snapshot, wrap_edits, None);
}
} else {
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 (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
assert_wrap_edits_cover_changes(
&mut previous_wrap_text,
&wraps_snapshot,
&wrap_edits,
);
block_map.read(wraps_snapshot, wrap_edits, None);
}
}
// Update a path's excerpts through `update_path_excerpts`,
// sometimes reusing a path key for a different buffer, as
// split diffs do when a file's diff base buffer is recreated.
82..=89 => {
let paths = multibuffer.read_with(cx, |multibuffer, cx| {
let snapshot = multibuffer.snapshot(cx);
snapshot
.all_buffer_ids()
.filter_map(|id| snapshot.path_for_buffer(id).cloned())
.collect::<Vec<_>>()
});
if paths.is_empty() || known_buffers.is_empty() {
continue;
}
let path = paths.choose(&mut rng).unwrap().clone();
let buffer = if rng.random_bool(0.5) {
let text = random_buffer_text(&mut rng);
let buffer = cx.new(|cx| Buffer::local(text, cx));
known_buffers.push(buffer.clone());
buffer
} else {
known_buffers.choose(&mut rng).unwrap().clone()
};
let max_row =
buffer.read_with(cx, |buffer, _| buffer.snapshot().max_point().row);
let ranges = (0..rng.random_range(0..=3))
.map(|_| {
let start_row = rng.random_range(0..=max_row);
let end_row = rng.random_range(start_row..=max_row);
Point::new(start_row, 0)..Point::new(end_row, 0)
})
.collect::<Vec<_>>();
log::info!("Setting excerpts for path {path:?} with ranges {ranges:?}");
multibuffer.update(cx, |multibuffer, cx| {
multibuffer.set_excerpts_for_path(path, buffer, ranges, 0, cx);
});
}
_ => {
// Base text buffers are read-only in production, so only
// edit buffers that are actually editable.
let buffers = multibuffer.read_with(cx, |multibuffer, cx| {
multibuffer
.all_buffers_iter()
.filter(|buffer| !buffer.read(cx).read_only())
.collect::<Vec<_>>()
});
let editable = buffers
.into_iter()
.chain(diffs.iter().map(|(_, buffer)| buffer.clone()))
.collect::<Vec<_>>();
let Some(buffer) = editable.choose(&mut rng).cloned() else {
continue;
};
buffer.update(cx, |buffer, cx| {
let edit_count = rng.random_range(1..=3);
buffer.randomly_edit(&mut rng, edit_count, cx);
});
// Recalculate any diff for the edited buffer, mirroring
// the recalculation that follows a buffer edit.
let snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
for (diff, diff_buffer) in &diffs {
if *diff_buffer == buffer {
diff.update(cx, |diff, cx| diff.recalculate_diff_sync(&snapshot, cx));
}
}
}
}
if !sync_now {
continue;
}
buffer_snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
let buffer_edits = subscription.consume().into_inner();
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
assert_wrap_edits_cover_changes(&mut previous_wrap_text, &wraps_snapshot, &wrap_edits);
let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None);
log::info!("blocks text: {:?}", blocks_snapshot.text());
assert_excerpts_resolve(&buffer_snapshot);
let max_row = blocks_snapshot.max_point().row;
for (row, block) in blocks_snapshot.blocks_in_range(BlockRow(0)..BlockRow(max_row + 1))
{
let excerpt = match block {
Block::BufferHeader { excerpt, .. }
| Block::ExcerptBoundary { excerpt, .. } => excerpt,
Block::FoldedBuffer { first_excerpt, .. } => first_excerpt,
_ => continue,
};
assert!(
buffer_snapshot.buffer_for_id(excerpt.buffer_id()).is_some(),
"stale header block {:?} at {row:?} references buffer {:?}, \
which is no longer in the multibuffer",
block.id(),
excerpt.buffer_id(),
);
}
}
}
#[gpui::test]
fn test_remove_intersecting_replace_blocks_edge_case(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "abc\ndef\nghi\njkl\nmno";
let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let (_inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (_fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (_tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let (_wrap_map, wraps_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
let _block_id = writer.insert(vec![BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
}])[0];
let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
assert_eq!(blocks_snapshot.text(), "abc\n\ndef\nghi\njkl\nmno");
let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
writer.remove_intersecting_replace_blocks(
[buffer_snapshot
.anchor_after(Point::new(1, 0))
.to_offset(&buffer_snapshot)
..buffer_snapshot
.anchor_after(Point::new(1, 0))
.to_offset(&buffer_snapshot)],
false,
);
let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
assert_eq!(blocks_snapshot.text(), "abc\n\ndef\nghi\njkl\nmno");
}
#[gpui::test]
fn test_folded_buffer_with_near_blocks(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "line 1\nline 2\nline 3";
let buffer = cx.update(|cx| {
MultiBuffer::build_multi([(text, vec![Point::new(0, 0)..Point::new(2, 6)])], cx)
});
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let buffer_ids = buffer_snapshot
.excerpts()
.map(|excerpt| excerpt.context.start.buffer_id)
.dedup()
.collect::<Vec<_>>();
assert_eq!(buffer_ids.len(), 1);
let buffer_id = buffer_ids[0];
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let (_, wrap_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wrap_snapshot.clone(), 1, 1);
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
writer.insert(vec![BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Near(buffer_snapshot.anchor_after(Point::new(0, 0))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
}]);
let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
assert_eq!(blocks_snapshot.text(), "\nline 1\n\nline 2\nline 3");
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
buffer.read_with(cx, |buffer, cx| {
writer.fold_buffers([buffer_id], buffer, cx);
});
let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
assert_eq!(blocks_snapshot.text(), "");
}
#[gpui::test]
fn test_folded_buffer_with_near_blocks_on_last_line(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let text = "line 1\nline 2\nline 3\nline 4";
let buffer = cx.update(|cx| {
MultiBuffer::build_multi([(text, vec![Point::new(0, 0)..Point::new(3, 6)])], cx)
});
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let buffer_ids = buffer_snapshot
.excerpts()
.map(|excerpt| excerpt.context.start.buffer_id)
.dedup()
.collect::<Vec<_>>();
assert_eq!(buffer_ids.len(), 1);
let buffer_id = buffer_ids[0];
let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let (_, wrap_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let mut block_map = BlockMap::new(wrap_snapshot.clone(), 1, 1);
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
writer.insert(vec![BlockProperties {
style: BlockStyle::Fixed,
placement: BlockPlacement::Near(buffer_snapshot.anchor_after(Point::new(3, 6))),
height: Some(1),
render: Arc::new(|_| div().into_any()),
priority: 0,
}]);
let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
assert_eq!(blocks_snapshot.text(), "\nline 1\nline 2\nline 3\nline 4\n");
let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
buffer.read_with(cx, |buffer, cx| {
writer.fold_buffers([buffer_id], buffer, cx);
});
let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
assert_eq!(blocks_snapshot.text(), "");
}
#[gpui::test]
fn test_companion_spacer_blocks(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let base_text = "aaa\nbbb\nccc\nddd\nddd\nddd\neee\n";
let main_text = "aaa\nddd\nddd\nddd\nXXX\nYYY\nZZZ\neee\n";
let rhs_buffer = cx.new(|cx| Buffer::local(main_text, cx));
let diff = cx.new(|cx| {
BufferDiff::new_with_base_text(base_text, &rhs_buffer.read(cx).text_snapshot(), cx)
});
let lhs_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
let lhs_multibuffer = cx.new(|cx| {
let mut mb = MultiBuffer::new(Capability::ReadWrite);
mb.set_excerpts_for_buffer(
lhs_buffer.clone(),
[Point::zero()..lhs_buffer.read(cx).max_point()],
0,
cx,
);
mb.add_inverted_diff(diff.clone(), rhs_buffer.clone(), cx);
mb
});
let rhs_multibuffer = cx.new(|cx| {
let mut mb = MultiBuffer::new(Capability::ReadWrite);
mb.set_excerpts_for_buffer(
rhs_buffer.clone(),
[Point::zero()..rhs_buffer.read(cx).max_point()],
0,
cx,
);
mb.add_diff(diff.clone(), cx);
mb
});
let subscription =
rhs_multibuffer.update(cx, |rhs_multibuffer, _| rhs_multibuffer.subscribe());
let lhs_buffer_snapshot = cx.update(|cx| lhs_multibuffer.read(cx).snapshot(cx));
let (mut _lhs_inlay_map, lhs_inlay_snapshot) = InlayMap::new(lhs_buffer_snapshot);
let (mut _lhs_fold_map, lhs_fold_snapshot) = FoldMap::new(lhs_inlay_snapshot);
let (mut _lhs_tab_map, lhs_tab_snapshot) =
TabMap::new(lhs_fold_snapshot, 4.try_into().unwrap());
let (_lhs_wrap_map, lhs_wrap_snapshot) =
cx.update(|cx| WrapMap::new(lhs_tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let lhs_block_map = BlockMap::new(lhs_wrap_snapshot.clone(), 0, 0);
let rhs_buffer_snapshot = cx.update(|cx| rhs_multibuffer.read(cx).snapshot(cx));
let (mut rhs_inlay_map, rhs_inlay_snapshot) = InlayMap::new(rhs_buffer_snapshot);
let (mut rhs_fold_map, rhs_fold_snapshot) = FoldMap::new(rhs_inlay_snapshot);
let (mut rhs_tab_map, rhs_tab_snapshot) =
TabMap::new(rhs_fold_snapshot, 4.try_into().unwrap());
let (_rhs_wrap_map, rhs_wrap_snapshot) =
cx.update(|cx| WrapMap::new(rhs_tab_snapshot, font("Helvetica"), px(14.0), None, cx));
let rhs_block_map = BlockMap::new(rhs_wrap_snapshot.clone(), 0, 0);
let rhs_entity_id = rhs_multibuffer.entity_id();
let companion = cx.new(|_| Companion::new(rhs_entity_id));
let rhs_edits = Patch::new(vec![text::Edit {
old: WrapRow(0)..rhs_wrap_snapshot.max_point().row(),
new: WrapRow(0)..rhs_wrap_snapshot.max_point().row(),
}]);
let lhs_edits = Patch::new(vec![text::Edit {
old: WrapRow(0)..lhs_wrap_snapshot.max_point().row(),
new: WrapRow(0)..lhs_wrap_snapshot.max_point().row(),
}]);
let rhs_snapshot = companion.read_with(cx, |companion, _cx| {
rhs_block_map.read(
rhs_wrap_snapshot.clone(),
rhs_edits.clone(),
Some(CompanionView::new(
rhs_entity_id,
&lhs_wrap_snapshot,
&lhs_edits,
companion,
)),
)
});
let lhs_entity_id = lhs_multibuffer.entity_id();
let lhs_snapshot = companion.read_with(cx, |companion, _cx| {
lhs_block_map.read(
lhs_wrap_snapshot.clone(),
lhs_edits.clone(),
Some(CompanionView::new(
lhs_entity_id,
&rhs_wrap_snapshot,
&rhs_edits,
companion,
)),
)
});
// LHS:
// aaa
// - bbb
// - ccc
// ddd
// ddd
// ddd
// <extra line>
// <extra line>
// <extra line>
// *eee
//
// RHS:
// aaa
// <extra line>
// <extra line>
// ddd
// ddd
// ddd
// + XXX
// + YYY
// + ZZZ
// eee
assert_eq!(
rhs_snapshot.snapshot.text(),
"aaa\n\n\nddd\nddd\nddd\nXXX\nYYY\nZZZ\neee\n",
"RHS should have 2 spacer lines after 'aaa' to align with LHS's deleted lines"
);
assert_eq!(
lhs_snapshot.snapshot.text(),
"aaa\nbbb\nccc\nddd\nddd\nddd\n\n\n\neee\n",
"LHS should have 3 spacer lines in place of RHS's inserted lines"
);
// LHS:
// aaa
// - bbb
// - ccc
// ddd
// ddd
// ddd
// <extra line>
// <extra line>
// <extra line>
// eee
//
// RHS:
// aaa
// <extra line>
// <extra line>
// ddd
// foo
// foo
// foo
// ddd
// ddd
// + XXX
// + YYY
// + ZZZ
// eee
let rhs_buffer_snapshot = rhs_multibuffer.update(cx, |multibuffer, cx| {
multibuffer.edit(
[(Point::new(2, 0)..Point::new(2, 0), "foo\nfoo\nfoo\n")],
None,
cx,
);
multibuffer.snapshot(cx)
});
let (rhs_inlay_snapshot, rhs_inlay_edits) =
rhs_inlay_map.sync(rhs_buffer_snapshot, subscription.consume().into_inner());
let (rhs_fold_snapshot, rhs_fold_edits) =
rhs_fold_map.read(rhs_inlay_snapshot, rhs_inlay_edits);
let (rhs_tab_snapshot, rhs_tab_edits) =
rhs_tab_map.sync(rhs_fold_snapshot, rhs_fold_edits, 4.try_into().unwrap());
let (rhs_wrap_snapshot, rhs_wrap_edits) = _rhs_wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(rhs_tab_snapshot, rhs_tab_edits, cx)
});
let rhs_snapshot = companion.read_with(cx, |companion, _cx| {
rhs_block_map.read(
rhs_wrap_snapshot.clone(),
rhs_wrap_edits.clone(),
Some(CompanionView::new(
rhs_entity_id,
&lhs_wrap_snapshot,
&Default::default(),
companion,
)),
)
});
let lhs_snapshot = companion.read_with(cx, |companion, _cx| {
lhs_block_map.read(
lhs_wrap_snapshot.clone(),
Default::default(),
Some(CompanionView::new(
lhs_entity_id,
&rhs_wrap_snapshot,
&rhs_wrap_edits,
companion,
)),
)
});
assert_eq!(
rhs_snapshot.snapshot.text(),
"aaa\n\n\nddd\nfoo\nfoo\nfoo\nddd\nddd\nXXX\nYYY\nZZZ\neee\n",
"RHS should have the insertion"
);
assert_eq!(
lhs_snapshot.snapshot.text(),
"aaa\nbbb\nccc\nddd\n\n\n\nddd\nddd\n\n\n\neee\n",
"LHS should have 3 more spacer lines to balance the insertion"
);
}
// Regression test for ZED-9V4: `BlockMap::sync` walks the (old) transform
// tree with a `WrapRow` cursor and used to `cursor.item().unwrap()` for
// every edit, assuming each edit's `old.start` lands strictly inside the
// tree. The companion (split-diff) branch of `sync` can compose an edit
// anchored at the trailing boundary of the old transforms
// (`old.start == input_rows`), at which point the cursor is past the end of
// the tree and `item()` is `None`. That used to abort the process.
#[gpui::test]
fn test_sync_edit_anchored_at_end_of_transforms(cx: &mut gpui::TestAppContext) {
cx.update(init_test);
let buffer = cx.update(|cx| MultiBuffer::build_simple("aaa\nbbb\nccc\n", cx));
let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot);
let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
let (wrap_map, old_wrap_snapshot) =
cx.update(|cx| WrapMap::new(tab_snapshot, test_font(), px(14.0), None, cx));
let block_map = BlockMap::new(old_wrap_snapshot.clone(), 0, 0);
// The tree now spans exactly `old_end` input rows.
let old_end = old_wrap_snapshot.max_point().row() + RowDelta(1);
// Grow the buffer so the new snapshot is larger than the old transforms.
let buffer_snapshot = buffer.update(cx, |buffer, cx| {
buffer.edit(
[(Point::new(3, 0)..Point::new(3, 0), "ddd\neee\n")],
None,
cx,
);
buffer.snapshot(cx)
});
let (inlay_snapshot, inlay_edits) =
inlay_map.sync(buffer_snapshot, subscription.consume().into_inner());
let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
let (tab_snapshot, tab_edits) =
tab_map.sync(fold_snapshot, fold_edits, 4.try_into().unwrap());
let (new_wrap_snapshot, _) = wrap_map.update(cx, |wrap_map, cx| {
wrap_map.sync(tab_snapshot, tab_edits, cx)
});
let new_end = new_wrap_snapshot.max_point().row() + RowDelta(1);
// An edit anchored exactly at the end of the old transforms, of the shape
// the companion branch of `sync` can produce.
let edits = Patch::new(vec![text::Edit {
old: old_end..old_end,
new: old_end..new_end,
}]);
let snapshot = block_map.read(new_wrap_snapshot, edits, None);
assert_eq!(snapshot.snapshot.text(), "aaa\nbbb\nccc\nddd\neee\n");
}
#[gpui::test]
fn test_replacement_input_ranges_preserve_partial_tab_rows(cx: &mut gpui::TestAppContext) {
cx.update(|cx| {
init_test(cx);
crate::init(cx);
});
let buffer = cx.update(|cx| {
MultiBuffer::build_simple("one two three\nfour five six\nseven eight", cx)
});
let map = cx.new(|cx| {
DisplayMap::new(
buffer,
font("Helvetica"),
px(14.0),
Some(px(90.)),
1,
1,
FoldPlaceholder::test(),
DiagnosticSeverity::Warning,
cx,
)
});
let mut snapshot = map.update(cx, |map, cx| map.snapshot(cx));
let wraps = snapshot.wrap_snapshot().clone();
assert_eq!(
wraps.text(),
"one two \nthree\nfour five \nsix\nseven \neight"
);
for height in [0, 1, 4] {
let block = Block::Custom(Arc::new(CustomBlock {
id: CustomBlockId(0),
placement: BlockPlacement::Replace(Anchor::Min..=Anchor::Max),
height: Some(height),
style: BlockStyle::Fixed,
render: Arc::new(Mutex::new(Arc::new(|_| div().into_any()))),
priority: 0,
}));
for (hidden, expected) in [
(0..6, [Some(0..=2), Some(0..=2), Some(0..=2)]),
(1..5, [None, Some(1..=1), None]),
(0..5, [Some(0..=1), Some(0..=1), None]),
(1..6, [None, Some(1..=2), Some(1..=2)]),
(2..4, [None, Some(1..=1), None]),
(0..2, [Some(0..=0), None, None]),
(4..6, [None, None, Some(2..=2)]),
(0..1, [None, None, None]),
(5..6, [None, None, None]),
] {
let mut transforms = SumTree::new(());
push_isomorphic(&mut transforms, RowDelta(hidden.start), &wraps);
transforms.push(
Transform {
summary: TransformSummary {
input_rows: WrapRow(hidden.end - hidden.start),
output_rows: BlockRow(height),
..TransformSummary::default()
},
block: Some(block.clone()),
},
(),
);
push_isomorphic(&mut transforms, RowDelta(6 - hidden.end), &wraps);
snapshot.block_snapshot.transforms = transforms;
assert_eq!(
(0..3)
.map(|row| snapshot.fully_replaced_tab_rows(row))
.collect::<Vec<_>>(),
expected,
"hidden: {hidden:?}, height: {height}"
);
for row in 0..=6 {
assert_eq!(
snapshot
.block_snapshot
.replacement_block_input_range(WrapRow(row)),
hidden
.contains(&row)
.then_some(WrapRow(hidden.start)..WrapRow(hidden.end)),
"row: {row}, hidden: {hidden:?}, height: {height}"
);
}
}
}
}
fn init_test(cx: &mut gpui::App) {
let settings = SettingsStore::test(cx);
cx.set_global(settings);
theme_settings::init(theme::LoadThemes::JustBase, cx);
assets::Assets.load_test_fonts(cx);
}
/// Verifies the edit coverage invariant at the wrap boundary: applying the
/// emitted edits to the previous wrap text must reproduce the new wrap
/// text exactly. A row that changed without being covered by an edit is
/// precisely the kind of under-invalidation that leaves the block map
/// holding stale header blocks (ZED-7G6), because every layer below the
/// block map propagates its changes only through these edits. Checking at
/// the wrap boundary catches under-coverage introduced by any layer
/// beneath it.
#[track_caller]
fn assert_wrap_edits_cover_changes(
previous_wrap_text: &mut String,
wrap_snapshot: &WrapSnapshot,
wrap_edits: &WrapPatch,
) {
let new_text = wrap_snapshot.text();
let old_rows = previous_wrap_text.split('\n').collect::<Vec<_>>();
let new_rows = new_text.split('\n').collect::<Vec<_>>();
let mut reconstructed = old_rows.clone();
for edit in wrap_edits.edits().iter().rev() {
assert!(
edit.old.start.0 as usize <= reconstructed.len()
&& edit.old.end.0 as usize <= old_rows.len(),
"edit {edit:?} lies outside the previous wrap text ({} rows)",
old_rows.len(),
);
assert!(
edit.new.end.0 as usize <= new_rows.len(),
"edit {edit:?} lies outside the new wrap text ({} rows)",
new_rows.len(),
);
reconstructed.splice(
edit.old.start.0 as usize..edit.old.end.0 as usize,
new_rows[edit.new.start.0 as usize..edit.new.end.0 as usize]
.iter()
.copied(),
);
}
assert_eq!(
reconstructed.join("\n"),
new_text,
"wrap edits do not cover all changed rows; edits: {wrap_edits:?}",
);
*previous_wrap_text = new_text;
}
/// Every excerpt must resolve its buffer, independently of any block: a
/// snapshot holding an excerpt whose buffer is absent would panic even when
/// the header rendering it was just computed.
#[track_caller]
fn assert_excerpts_resolve(buffer_snapshot: &MultiBufferSnapshot) {
for excerpt in buffer_snapshot.excerpts() {
let buffer_id = excerpt.context.start.buffer_id;
assert!(
buffer_snapshot.buffer_for_id(buffer_id).is_some(),
"multibuffer snapshot holds an excerpt for buffer {buffer_id:?}, \
which is absent from its buffers",
);
}
}
/// Empty and single-line buffers are generated often because excerpts
/// holding no text produce zero-width edits, which `Patch` discards.
fn random_buffer_text(rng: &mut StdRng) -> String {
let len = match rng.random_range(0..100) {
0..=29 => 0,
30..=59 => rng.random_range(1..4),
_ => rng.random_range(4..30),
};
RandomCharIter::new(rng).take(len).collect()
}
fn randomized_text(text: &str, rng: &mut StdRng) -> String {
let mut chars = text.chars().collect::<Vec<_>>();
for _ in 0..rng.random_range(1..=3) {
if chars.is_empty() || rng.random_bool(0.5) {
let insert_at = rng.random_range(0..=chars.len());
let insert_len = rng.random_range(1..5);
for (offset, c) in RandomCharIter::new(&mut *rng).take(insert_len).enumerate() {
chars.insert(insert_at + offset, c);
}
} else {
let start = rng.random_range(0..chars.len());
let end = rng.random_range(start + 1..=chars.len());
chars.drain(start..end);
}
}
chars.into_iter().collect()
}
impl Block {
fn as_custom(&self) -> Option<&CustomBlock> {
match self {
Block::Custom(block) => Some(block),
_ => None,
}
}
}
impl BlockSnapshot {
fn to_point(&self, point: BlockPoint, bias: Bias) -> Point {
self.wrap_snapshot
.to_point(self.to_wrap_point(point, bias), bias)
}
}
}