Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
editor: Fix columnar selection coordinates (#63723)
itsfuad3d91988e46c4
diff --git a/crates/editor/src/columnar_selection.rs b/crates/editor/src/columnar_selection.rsnew file mode 100644index 00000000000..99654c89c25--- /dev/null+++ b/crates/editor/src/columnar_selection.rs@@ -0,0 +1,2852 @@+use language::{Bias, LanguageAwareStyling, Point};+use multi_buffer::{MBTextSummary, MultiBufferRow};+use std::ops::Range;+use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};++use crate::{+ DisplayPoint,+ display_map::{DisplaySnapshot, FoldPoint, Highlights, TabPoint, ToDisplayPoint as _},+};++pub(crate) struct ColumnarSelectionRows<'a> {+ snapshot: &'a DisplaySnapshot,+}++impl<'a> ColumnarSelectionRows<'a> {+ pub(crate) fn new(snapshot: &'a DisplaySnapshot) -> Self {+ Self { snapshot }+ }++ pub(crate) fn columns_for_ranges(&mut self, ranges: &[Range<Point>]) -> Vec<Range<u32>> {+ let tabs = self.snapshot.tab_snapshot();+ let mut endpoints = ranges+ .iter()+ .enumerate()+ .flat_map(|(index, range)| {+ [(range.start, false), (range.end, true)]+ .map(|(point, end)| (tabs.point_to_tab_point(point, Bias::Left), index, end))+ })+ .collect::<Vec<_>>();+ endpoints.sort_unstable();+ let mut answers = vec![0..0; ranges.len()];+ for endpoints in endpoints.chunk_by(|left, right| left.0.row() == right.0.row()) {+ let mut text = self.row(endpoints[0].0.row());+ let mut cursor = text.forward_cursor();+ for &(point, index, end) in endpoints {+ text.floor_forward(&mut cursor, point.column());+ if end {+ answers[index].end = cursor.column;+ } else {+ answers[index].start = cursor.column;+ }+ }+ }+ for answer in &mut answers {+ *answer = answer.start.min(answer.end)..answer.start.max(answer.end);+ }+ answers+ }++ pub(crate) fn points_for_rows(+ &mut self,+ queries: &[(u32, Range<u32>)],+ ) -> Vec<Option<(Point, Point)>> {+ let tabs = self.snapshot.tab_snapshot();+ let max_row = tabs.max_point().row();+ let mut endpoints = Vec::new();+ for (index, (row, columns)) in queries.iter().enumerate() {+ if *row <= max_row && columns.start <= columns.end {+ endpoints.push((*row, columns.start, false, index));+ if columns.start != columns.end {+ endpoints.push((*row, columns.end, true, index));+ }+ }+ }+ endpoints.sort_unstable();+ let mut answers = vec![None::<(Point, Point)>; queries.len()];+ for endpoints in endpoints.chunk_by(|left, right| left.0 == right.0) {+ let row = endpoints[0].0;+ let length = tabs.line_len(row);+ let mut text = self.row(row);+ let mut cursor = text.cursor(0);+ let mut column = 0;+ let mut preceding = None;+ let mut buffer_cursor = None;+ for &(_, goal, end, index) in endpoints {+ let columns = &queries[index].1;+ if (end && answers[index].is_none())+ || (!end && columns.start != columns.end && goal >= length)+ {+ continue;+ }+ text.advance_columns(&mut cursor, goal - column);+ column = goal;+ if !end && columns.start != columns.end && cursor.byte() == length {+ continue;+ }+ let point = self.point_for_cursor(+ row,+ &mut text,+ cursor.clone(),+ preceding,+ &mut buffer_cursor,+ );+ preceding = Some((cursor.byte(), point));+ answers[index] = if end {+ answers[index]+ .zip(point)+ .map(|((start, _), end)| (start.min(end), start.max(end)))+ } else {+ point.map(|point| (point, point))+ };+ }+ }+ answers+ }++ #[cfg(test)]+ pub(crate) fn columns_for_range(&mut self, range: Range<Point>) -> Range<u32> {+ self.columns_for_ranges(&[range]).pop().expect("one range")+ }++ #[cfg(test)]+ pub(crate) fn points_for_row(+ &mut self,+ row: u32,+ columns: &Range<u32>,+ ) -> Option<(Point, Point)> {+ self.points_for_rows(&[(row, columns.clone())])+ .pop()+ .flatten()+ }++ fn point_for_cursor(+ &self,+ row: u32,+ text: &mut RowText<'a>,+ mut cursor: BoundaryCursor,+ preceding: Option<(u32, Option<Point>)>,+ buffer_cursor: &mut Option<BufferRowCursor<'a>>,+ ) -> Option<Point> {+ let frontier = preceding.map_or(0, |(byte, _)| byte);+ let mut backward_buffer_cursor = None;+ if let Some(buffer_cursor) = buffer_cursor {+ buffer_cursor.reverse = None;+ }+ loop {+ if let Some((byte, point)) = preceding+ && cursor.byte() <= byte+ {+ return point;+ }+ let tab_point = TabPoint::new(row, cursor.byte());+ let tabs = self.snapshot.tab_snapshot();+ let fold_point = tabs.tab_point_to_fold_point(tab_point, Bias::Left).0;+ if let Some(range) = self+ .snapshot+ .fold_snapshot()+ .placeholder_range_at(fold_point)+ && range.start < fold_point+ {+ let start = tabs.fold_point_to_tab_point(range.start);+ text.retreat_to(&mut cursor, start.column().max(frontier));+ continue;+ }+ let point = tabs.tab_point_to_point(tab_point, Bias::Left);+ let display_point = point.to_display_point(self.snapshot);+ let hidden = self.snapshot.is_block_line(display_point.row());+ let canonical = tabs.point_to_tab_point(point, Bias::Left);+ if !hidden+ && canonical == tab_point+ && self.floor_buffer_point(buffer_cursor, &mut backward_buffer_cursor, point)+ == point+ {+ return Some(point);+ }+ let preceding = if hidden && canonical == tab_point {+ let hidden_start = self.snapshot.display_point_to_fold_point(+ DisplayPoint::new(display_point.row(), 0),+ Bias::Left,+ );+ let hidden_start = tabs.fold_point_to_tab_point(hidden_start);+ if hidden_start.row() != row {+ return None;+ }+ if hidden_start < tab_point {+ hidden_start+ } else {+ TabPoint::new(row, hidden_start.column().checked_sub(1)?)+ }+ } else if canonical < tab_point {+ canonical+ } else {+ let previous = if let Some(byte) = point.column.checked_sub(1) {+ self.floor_buffer_point(+ buffer_cursor,+ &mut backward_buffer_cursor,+ Point::new(point.row, byte),+ )+ } else {+ let row = point.row.checked_sub(1)?;+ Point::new(+ row,+ self.snapshot+ .buffer_snapshot()+ .line_len(MultiBufferRow(row)),+ )+ };+ tabs.point_to_tab_point(previous, Bias::Left)+ };+ if preceding.row() != row {+ return None;+ }+ if preceding < tab_point {+ text.retreat_to(&mut cursor, preceding.column().max(frontier));+ } else {+ text.previous_boundary(&mut cursor)?;+ }+ }+ }++ fn floor_buffer_point(+ &self,+ forward: &mut Option<BufferRowCursor<'a>>,+ backward: &mut Option<BufferRowCursor<'a>>,+ point: Point,+ ) -> Point {+ if forward.as_ref().is_none_or(|cursor| cursor.row < point.row) {+ *backward = forward.replace(self.buffer_row_cursor(point.row));+ }+ let cursor = if let Some(cursor) = forward.as_mut().filter(|cursor| cursor.row == point.row)+ {+ cursor+ } else {+ if backward+ .as_ref()+ .is_none_or(|cursor| cursor.row != point.row)+ {+ let cursor = backward.insert(self.buffer_row_cursor(point.row));+ cursor.reverse = Some(cursor.text.floor_at(point.column));+ }+ backward.as_mut().expect("backward buffer row initialized")+ };+ if cursor.reverse.is_none() {+ cursor.text.floor_forward(&mut cursor.forward, point.column);+ cursor.reverse = Some(cursor.forward.boundary.clone());+ }+ let boundary = cursor+ .reverse+ .as_mut()+ .expect("buffer boundary initialized");+ cursor.text.retreat_to(boundary, point.column);+ Point::new(point.row, boundary.byte())+ }++ fn buffer_row_cursor(&self, row: u32) -> BufferRowCursor<'a> {+ let text = self.buffer_row(row);+ let forward = text.forward_cursor();+ BufferRowCursor {+ row,+ text,+ forward,+ reverse: None,+ }+ }++ fn buffer_row(&self, row: u32) -> RowText<'a> {+ let buffer = self.snapshot.buffer_snapshot();+ let length = buffer.line_len(MultiBufferRow(row));+ let range = Point::new(row, 0)..Point::new(row, length);+ let summary = buffer.text_summary_for_range::<MBTextSummary, _>(range.clone());+ if summary.len.0 == summary.chars {+ RowText::Ascii(length)+ } else {+ RowText::new(length, buffer.text_for_range(range))+ }+ }++ fn row(&self, row: u32) -> RowText<'a> {+ let tabs = self.snapshot.tab_snapshot();+ let folds = self.snapshot.fold_snapshot();+ let summary = folds.text_summary_for_range(+ FoldPoint::new(row, 0)..FoldPoint::new(row, folds.line_len(row)),+ );+ let length = tabs.line_len(row);+ if summary.len.0 == summary.chars {+ RowText::Ascii(length)+ } else {+ let chunks = tabs+ .chunks(+ TabPoint::new(row, 0)..TabPoint::new(row, length),+ LanguageAwareStyling {+ tree_sitter: false,+ diagnostics: false,+ },+ Highlights::default(),+ )+ .map(|chunk| (chunk.text, chunk.is_tab));+ RowText::with_tabs(length, chunks)+ }+ }+}++enum RowText<'a> {+ Ascii(u32),+ Unicode(RowChunks<'a>),+}++struct RowChunks<'a> {+ length: u32,+ chunks: Vec<TextChunk<'a>>,+ remaining: Box<dyn Iterator<Item = (&'a str, bool)> + 'a>,+ #[cfg(test)]+ context_bytes: usize,+}++#[derive(Clone, Copy)]+struct TextChunk<'a> {+ start: usize,+ text: &'a str,+}++#[derive(Clone)]+struct BoundaryCursor {+ graphemes: GraphemeCursor,+ chunk_index: usize,+}++struct ForwardCursor {+ boundary: BoundaryCursor,+ next: BoundaryCursor,+ column: u32,+}++struct BufferRowCursor<'a> {+ row: u32,+ text: RowText<'a>,+ forward: ForwardCursor,+ reverse: Option<BoundaryCursor>,+}++#[derive(Clone, Copy, PartialEq, Eq)]+enum BoundaryQuery {+ Next,+ Previous,+ Check,+}++impl<'a> RowText<'a> {+ fn new(length: u32, chunks: impl Iterator<Item = &'a str> + 'a) -> Self {+ Self::with_tabs(length, chunks.map(|text| (text, false)))+ }++ fn with_tabs(length: u32, chunks: impl Iterator<Item = (&'a str, bool)> + 'a) -> Self {+ Self::Unicode(RowChunks {+ length,+ chunks: Vec::new(),+ remaining: Box::new(chunks),+ #[cfg(test)]+ context_bytes: 0,+ })+ }++ fn cursor(&self, byte: u32) -> BoundaryCursor {+ let length = match self {+ Self::Ascii(length) => *length,+ Self::Unicode(chunks) => chunks.length,+ };+ BoundaryCursor {+ graphemes: GraphemeCursor::new(byte.min(length) as usize, length as usize, true),+ chunk_index: 0,+ }+ }++ fn forward_cursor(&self) -> ForwardCursor {+ let boundary = self.cursor(0);+ ForwardCursor {+ next: boundary.clone(),+ boundary,+ column: 0,+ }+ }++ fn floor_forward(&mut self, cursor: &mut ForwardCursor, byte: u32) {+ debug_assert!(byte >= cursor.boundary.byte());+ if let Self::Ascii(length) = self {+ cursor.column = byte.min(*length);+ cursor.boundary.graphemes.set_cursor(cursor.column as usize);+ return;+ }+ while cursor.boundary.byte() < byte {+ if cursor.next.byte() == cursor.boundary.byte()+ && self.next_boundary(&mut cursor.next).is_none()+ {+ break;+ }+ if cursor.next.byte() > byte {+ break;+ }+ cursor.boundary = cursor.next.clone();+ cursor.column += 1;+ }+ }++ #[cfg(test)]+ fn columns_for_bytes(&mut self, bytes: Range<u32>) -> Range<u32> {+ let mut cursor = self.forward_cursor();+ self.floor_forward(&mut cursor, bytes.start);+ let start = cursor.column;+ self.floor_forward(&mut cursor, bytes.end);+ start..cursor.column+ }++ fn advance_columns(&mut self, cursor: &mut BoundaryCursor, count: u32) {+ if let Self::Ascii(length) = self {+ cursor+ .graphemes+ .set_cursor(cursor.byte().saturating_add(count).min(*length) as usize);+ } else {+ for _ in 0..count {+ if self.next_boundary(cursor).is_none() {+ break;+ }+ }+ }+ }++ fn floor_at(&mut self, byte: u32) -> BoundaryCursor {+ let mut cursor = self.cursor(byte);+ if let Self::Unicode(chunks) = self+ && cursor.byte() > 0+ && cursor.byte() < chunks.length+ {+ cursor.chunk_index = chunks.locate(cursor.byte() as usize);+ let chunk = chunks.chunk(cursor.chunk_index);+ let mut offset = cursor.byte() as usize - chunk.start;+ while !chunk.text.is_char_boundary(offset) {+ offset -= 1;+ }+ cursor.graphemes.set_cursor(chunk.start + offset);+ if chunks.resolve(&mut cursor, BoundaryQuery::Check).is_none() {+ chunks+ .resolve(&mut cursor, BoundaryQuery::Previous)+ .expect("non-boundary has a preceding boundary");+ }+ }+ cursor+ }++ fn retreat_to(&mut self, cursor: &mut BoundaryCursor, byte: u32) {+ if let Self::Ascii(_) = self {+ cursor+ .graphemes+ .set_cursor(cursor.byte().min(byte) as usize);+ } else {+ while cursor.byte() > byte {+ if self.previous_boundary(cursor).is_none() {+ break;+ }+ }+ }+ }++ fn next_boundary(&mut self, cursor: &mut BoundaryCursor) -> Option<u32> {+ match self {+ Self::Ascii(length) => {+ if cursor.byte() >= *length {+ return None;+ }+ cursor.graphemes.set_cursor(cursor.byte() as usize + 1);+ Some(cursor.byte())+ }+ Self::Unicode(chunks) => chunks.resolve(cursor, BoundaryQuery::Next),+ }+ }++ fn previous_boundary(&mut self, cursor: &mut BoundaryCursor) -> Option<u32> {+ match self {+ Self::Ascii(_) => {+ let byte = cursor.byte().checked_sub(1)?;+ cursor.graphemes.set_cursor(byte as usize);+ Some(byte)+ }+ Self::Unicode(chunks) => chunks.resolve(cursor, BoundaryQuery::Previous),+ }+ }+}++impl<'a> RowChunks<'a> {+ fn chunk(&mut self, index: usize) -> TextChunk<'a> {+ const TAB_CHARACTERS: [u8; 128] = [b'\t'; 128];+ while self.chunks.len() <= index {+ let (text, is_tab) = self+ .remaining+ .find(|(text, _)| !text.is_empty())+ .expect("row chunks must cover the row");+ let text = if is_tab {+ std::str::from_utf8(&TAB_CHARACTERS[..text.len()]).expect("tab controls are UTF-8")+ } else {+ text+ };+ let start = self+ .chunks+ .last()+ .map_or(0, |chunk| chunk.start + chunk.text.len());+ self.chunks.push(TextChunk { start, text });+ #[cfg(test)]+ tests::ROW_WORK.with(|work| {+ let (boundaries, chunks) = work.get();+ work.set((boundaries, chunks + 1));+ });+ }+ self.chunks[index]+ }++ fn locate(&mut self, byte: usize) -> usize {+ while self+ .chunks+ .last()+ .is_none_or(|chunk| chunk.start + chunk.text.len() <= byte)+ {+ self.chunk(self.chunks.len());+ }+ self.chunks.partition_point(|chunk| chunk.start <= byte) - 1+ }++ fn resolve(&mut self, cursor: &mut BoundaryCursor, query: BoundaryQuery) -> Option<u32> {+ #[cfg(test)]+ tests::ROW_WORK.with(|work| {+ let (boundaries, chunks) = work.get();+ work.set((boundaries + 1, chunks));+ });+ loop {+ let offset = cursor.graphemes.cur_cursor();+ if query == BoundaryQuery::Check && (offset == 0 || offset == self.length as usize) {+ return Some(offset as u32);+ }+ if (query == BoundaryQuery::Next && offset == self.length as usize)+ || (query == BoundaryQuery::Previous && offset == 0)+ {+ return None;+ }+ let chunk = loop {+ let chunk = self.chunk(cursor.chunk_index);+ if offset < chunk.start+ || (query == BoundaryQuery::Previous && offset == chunk.start)+ {+ cursor.chunk_index -= 1;+ } else if offset > chunk.start + chunk.text.len()+ || (query != BoundaryQuery::Previous+ && offset == chunk.start + chunk.text.len())+ {+ cursor.chunk_index += 1;+ } else {+ break chunk;+ }+ };+ let mut bridge = [0; 8];+ let (text, start) =+ if query != BoundaryQuery::Previous && offset == chunk.start && offset > 0 {+ let previous = self.chunk(cursor.chunk_index - 1);+ let previous = previous.text.chars().next_back().expect("nonempty chunk");+ let following = chunk.text.chars().next().expect("nonempty chunk");+ let previous_length = previous.encode_utf8(&mut bridge).len();+ let following_length =+ following.encode_utf8(&mut bridge[previous_length..]).len();+ (+ std::str::from_utf8(&bridge[..previous_length + following_length])+ .expect("encoded scalars are UTF-8"),+ offset - previous_length,+ )+ } else {+ (chunk.text, chunk.start)+ };+ loop {+ let result = match query {+ BoundaryQuery::Next => cursor.graphemes.next_boundary(text, start),+ BoundaryQuery::Previous => cursor.graphemes.prev_boundary(text, start),+ BoundaryQuery::Check => cursor+ .graphemes+ .is_boundary(text, start)+ .map(|boundary| boundary.then_some(cursor.graphemes.cur_cursor())),+ };+ match result {+ Ok(boundary) => return boundary.map(|byte| byte as u32),+ Err(GraphemeIncomplete::PreContext(end)) => {+ let index = self.locate(end - 1);+ let context = self.chunk(index);+ let context_text = &context.text[..end - context.start];+ #[cfg(test)]+ {+ self.context_bytes += context_text.len();+ }+ cursor+ .graphemes+ .provide_context(context_text, context.start);+ }+ Err(GraphemeIncomplete::NextChunk | GraphemeIncomplete::PrevChunk) => break,+ Err(error) => unreachable!("row grapheme cursor: {error:?}"),+ }+ }+ }+ }+}++impl BoundaryCursor {+ fn byte(&self) -> u32 {+ self.graphemes.cur_cursor() as u32+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{+ AddSelectionAbove, AddSelectionBelow, SelectionEffects,+ display_map::{+ BlockPlacement, BlockProperties, BlockStyle, Crease, DisplayMap, FoldPlaceholder,+ },+ inlays::Inlay,+ test::{editor_test_context::EditorTestContext, test_font},+ };+ use collections::HashSet;+ use gpui::{+ AppContext as _, BorrowAppContext as _, Element as _, Entity, Pixels, SharedString,+ TestAppContext, div, px,+ };+ use language::{Buffer, Capability};+ use multi_buffer::{Anchor, ExcerptRange, MultiBuffer, MultiBufferOffset, PathKey};+ use project::project_settings::DiagnosticSeverity;+ use rand::prelude::*;+ use settings::SettingsStore;+ use std::{cell::Cell, env, iter, num::NonZeroU32, sync::Arc};+ use theme::LoadThemes;+ use unicode_segmentation::UnicodeSegmentation as _;++ thread_local! {+ pub(super) static ROW_WORK: Cell<(usize, usize)> = const { Cell::new((0, 0)) };+ }++ #[gpui::test]+ async fn test_columnar_selection_actions_batch_work(cx: &mut TestAppContext) {+ crate::editor_tests::init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ let rows = [("é.", 3, 2), ("e\u{301}.", 4, 3), ("🦀.", 5, 4)];+ for count in [32, 128] {+ let text = rows+ .iter()+ .map(|(unit, _, _)| unit.repeat(count))+ .collect::<Vec<_>>()+ .join("\n");+ for above in [false, true] {+ for (nonempty, reversed) in [(false, false), (true, false), (true, true)] {+ let indices = if nonempty { 0..count } else { 1..count + 1 };+ let expected = |added| {+ rows.iter()+ .enumerate()+ .filter(|(row, _)| {+ if above {+ *row >= 2 - added+ } else {+ *row <= added+ }+ })+ .flat_map(|(row, &(_, stride, width))| {+ separated_columnar_ranges(+ row as u32,+ indices.clone(),+ stride,+ if nonempty { width } else { 0 },+ reversed,+ )+ })+ .collect::<Vec<_>>()+ };+ set_columnar_action_state(&mut cx, &text, &expected(0));+ for (direction, added) in [+ (above, 1),+ (above, 2),+ (above, 2),+ (!above, 1),+ (!above, 0),+ (above, 1),+ ] {+ let expected = expected(added);+ assert_eq!(expected.len(), (added + 1) * count);+ assert_columnar_action_work(&mut cx, direction, &expected, 4 * (2 * count));+ }+ }+ }+ }+ }++ #[gpui::test]+ async fn test_columnar_selection_actions_join_skipped_rows_work(cx: &mut TestAppContext) {+ crate::editor_tests::init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for count in [32, 128] {+ for above in [false, true] {+ let row = |row| if above { 6 - row } else { row };+ let mut lines = [+ "é.".repeat(count + 1),+ "é".to_owned(),+ "e\u{301}.".repeat(count / 2 + 1),+ String::new(),+ "🦀.".to_owned(),+ "🦀.".repeat(count + 1),+ "e\u{301}.".repeat(count + 1),+ ];+ if above {+ lines.reverse();+ }+ let text = lines.join("\n");+ for reversed in [false, true] {+ let sources =+ separated_columnar_ranges(row(0), count / 2 + 1..count + 1, 3, 2, reversed)+ .into_iter()+ .chain(separated_columnar_ranges(+ row(2),+ 1..count / 2 + 1,+ 4,+ 3,+ reversed,+ ))+ .collect::<Vec<_>>();+ let expected = |added| {+ let mut expected = sources.clone();+ for (target, stride, width) in+ [(5, 5, 4), (6, 4, 3)].into_iter().take(added)+ {+ expected.extend(separated_columnar_ranges(+ row(target),+ 1..count + 1,+ stride,+ width,+ reversed,+ ));+ }+ expected.sort_unstable_by_key(|range| range.start.min(range.end));+ expected+ };+ set_columnar_action_state(&mut cx, &text, &expected(0));+ for (direction, added) in [+ (above, 1),+ (above, 2),+ (above, 2),+ (!above, 1),+ (!above, 0),+ (above, 1),+ ] {+ let expected = expected(added);+ assert_eq!(expected.len(), (added + 1) * count);+ assert_columnar_action_work(+ &mut cx,+ direction,+ &expected,+ 5 * (2 * (count + 1)),+ );+ }+ }+ }+ }+ }++ #[gpui::test]+ async fn test_columnar_selection_actions_skip_replaced_source_rows(cx: &mut TestAppContext) {+ crate::editor_tests::init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for hidden_count in [1, 128] {+ let text = iter::repeat_n("éab", hidden_count as usize + 3)+ .collect::<Vec<_>>()+ .join("\n");+ for above in [false, true] {+ let row = |row| if above { hidden_count + 2 - row } else { row };+ for ends_inside_replacement in [false, true] {+ let end_row = hidden_count + u32::from(!ends_inside_replacement);+ let source = Point::new(row(0).min(row(end_row)), 2)+ ..Point::new(row(0).max(row(end_row)), 3);+ set_columnar_action_state(&mut cx, &text, &[source]);+ let blocks = cx.update_editor(|editor, _, cx| {+ let buffer = editor.buffer.read(cx).snapshot(cx);+ editor.insert_blocks(+ [BlockProperties {+ placement: BlockPlacement::Replace(+ buffer+ .anchor_after(Point::new(row(1).min(row(hidden_count)), 0))+ ..=buffer.anchor_before(Point::new(+ row(1).max(row(hidden_count)),+ 4,+ )),+ ),+ height: Some(1),+ style: BlockStyle::Fixed,+ render: Arc::new(|_| div().into_any()),+ priority: 0,+ }],+ None,+ cx,+ )+ });+ let mut expected = [0, hidden_count + 1, hidden_count + 2]+ .into_iter()+ .take(if ends_inside_replacement { 2 } else { 3 })+ .map(|source_row| {+ Point::new(row(source_row), 2)..Point::new(row(source_row), 3)+ })+ .collect::<Vec<_>>();+ expected.sort_unstable_by_key(|range| range.start);+ assert_columnar_action_work(&mut cx, above, &expected, 32);+ cx.update_editor(|editor, _, cx| {+ editor.remove_blocks(blocks.into_iter().collect(), None, cx);+ });+ }+ }+ }+ }++ #[gpui::test]+ fn test_columnar_selection_batch_work(cx: &mut TestAppContext) {+ init_test(cx);+ let length = 4096;+ let line = "é".repeat(length);+ let snapshot = plain_state(&format!("{line}\n{line}"), cx)+ .build_map(cx)+ .update(cx, |map, cx| map.snapshot(cx));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ let mut ranges = (0..length as u32)+ .flat_map(|column| {+ (0..2)+ .map(move |row| Point::new(row, column * 2)..Point::new(row, length as u32 * 2))+ })+ .collect::<Vec<_>>();+ let mut expected_columns = (0..length as u32)+ .flat_map(|column| [column..length as u32, column..length as u32])+ .collect::<Vec<_>>();+ for _ in 0..2 {+ ROW_WORK.set((0, 0));+ let answers = query.columns_for_ranges(&ranges);+ assert_eq!(answers.len(), expected_columns.len());+ for (index, (answer, expected)) in answers.iter().zip(&expected_columns).enumerate() {+ assert_eq!(answer, expected, "range {index}");+ }+ let (boundaries, chunks) = ROW_WORK.get();+ assert_eq!(boundaries, 2 * length);+ assert!(chunks <= 2 * length);+ ranges.reverse();+ expected_columns.reverse();+ }+ let requests = (0..length as u32)+ .flat_map(|column| (0..2).map(move |row| (row, column..length as u32)))+ .collect::<Vec<_>>();+ let expected_points = (0..length as u32)+ .flat_map(|column| {+ (0..2).map(move |row| {+ Some((+ Point::new(row, column * 2),+ Point::new(row, length as u32 * 2),+ ))+ })+ })+ .collect::<Vec<_>>();+ assert_batch_points(&mut query, requests, expected_points, 4 * length);+ assert_eq!(query.columns_for_ranges(&[]), Vec::new());+ assert_eq!(query.points_for_rows(&[]), Vec::new());+ }++ #[gpui::test]+ fn test_columnar_selection_batch_fold_projection(cx: &mut TestAppContext) {+ init_test(cx);+ let length = 128;+ let prefix = "é".repeat(length);+ let indicators = "🇦".repeat(length);+ let mut state = plain_state(&format!("{prefix}\n{indicators}\n{indicators}"), cx);+ let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));+ state.folds = vec![+ buffer.anchor_after(Point::new(0, length as u32 * 2))+ ..buffer.anchor_before(Point::new(1, 4)),+ buffer.anchor_after(Point::new(1, length as u32 * 4))+ ..buffer.anchor_before(Point::new(2, 4)),+ ];+ let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));+ let visible_indicators = "🇦".repeat(length - 1);+ assert_eq!(+ snapshot.tab_snapshot().text(),+ format!("{prefix}⋯{visible_indicators}⋯{visible_indicators}")+ );+ let end_column = length as u32 * 2 + 2;+ let end = Point::new(2, length as u32 * 4);+ let requests = (0..=end_column)+ .flat_map(|column| [(0, column..column), (0, column..end_column)])+ .collect::<Vec<_>>();+ let expected = (0..=end_column)+ .flat_map(|column| {+ let point = if column <= length as u32 {+ Point::new(0, column * 2)+ } else if column <= length as u32 * 3 / 2 {+ Point::new(0, length as u32 * 2)+ } else if column < end_column {+ Point::new(1, length as u32 * 4)+ } else {+ end+ };+ [Some((point, point)), Some((point, end))]+ })+ .collect::<Vec<_>>();+ let mut query = ColumnarSelectionRows::new(&snapshot);+ assert_batch_points(&mut query, requests, expected, 16 * length);+ }++ #[gpui::test]+ fn test_columnar_selection_batch_rejects_before_end(cx: &mut TestAppContext) {+ init_test(cx);+ let mut state = plain_state("x\né\n", cx);+ let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));+ state.inlays.push(Inlay::mock_hint(+ 0,+ buffer.anchor_before(Point::new(1, 0)),+ &format!("é{}\n", "a".repeat(1_048_576)),+ ));+ let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ let mut requests = vec![(1, 0..u32::MAX); 4096];+ requests.extend([(2, 1..u32::MAX), (0, 2..u32::MAX), (u32::MAX, 0..0)]);+ for _ in 0..2 {+ ROW_WORK.set((0, 0));+ assert_eq!(query.points_for_rows(&requests), vec![None; requests.len()]);+ assert_eq!(ROW_WORK.get(), (1, 1));+ requests.reverse();+ }+ }++ #[gpui::test]+ fn test_columnar_selection_batch_virtual_frontier_work(cx: &mut TestAppContext) {+ init_test(cx);+ for (folded, length, prefix_length) in [(false, 4096, 1), (true, 64, 1), (true, 4096, 256)]+ {+ let prefix = "a".repeat(prefix_length);+ let placeholder = "é".repeat(length);+ let point = Point::new(0, prefix_length as u32);+ let mut state = plain_state(&format!("{prefix}xb"), cx);+ if !folded {+ let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));+ state.inlays.push(Inlay::mock_hint(+ 0,+ buffer.anchor_after(point),+ &placeholder,+ ));+ }+ let map = state.build_map(cx);+ if folded {+ map.update(cx, |map, cx| {+ map.fold(+ vec![Crease::simple(+ point..Point::new(0, point.column + 1),+ FoldPlaceholder {+ collapsed_text: Some(SharedString::from(placeholder.clone())),+ ..FoldPlaceholder::test()+ },+ )],+ cx,+ )+ });+ }+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(+ snapshot.tab_snapshot().text(),+ if folded {+ format!("{prefix}{placeholder}b")+ } else {+ format!("{prefix}{placeholder}xb")+ }+ );+ let end = point.column + length as u32 - 1;+ let requests = (point.column..=end)+ .flat_map(|column| [(0, column..column), (0, column..end)])+ .collect::<Vec<_>>();+ let expected = vec![Some((point, point)); requests.len()];+ assert_batch_points(+ &mut ColumnarSelectionRows::new(&snapshot),+ requests,+ expected,+ 8 * length,+ );+ }+ }++ #[gpui::test]+ fn test_columnar_selection_batch_frontier_across_original_rows(+ cx: &mut TestAppContext,+ mut rng: StdRng,+ ) {+ init_test(cx);+ let lines = [+ "ééé",+ "🇦🇶🇦🇶🇦🇶🇦",+ "🇦🇶🇦🇶🇦🇶🇦🇶",+ "\t\u{301}界",+ "\u{600}e\u{301}",+ "👩🏽\u{200d}💻",+ "क्\u{200d}ष",+ "\u{1100}\u{1161}\u{11a8}",+ "\u{301}\u{301}",+ "a\0\u{200b}b",+ "é界🏀",+ "✈\u{fe0f}1\u{fe0f}\u{20e3}",+ "का",+ "",+ ];+ for tab_size in [1, 128] {+ set_tab_size(tab_size, cx);+ for bias in [None, Some(Bias::Left), Some(Bias::Right)] {+ let mut state = plain_state(&lines.join("\n"), cx);+ let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));+ for (row, line) in lines.iter().enumerate().skip(1) {+ let Some(first) = line.chars().next() else {+ continue;+ };+ let point = Point::new(row as u32, first.len_utf8() as u32);+ if row % 4 != 0 {+ state.folds.push(+ buffer.anchor_after(Point::new(+ row as u32 - 1,+ lines[row - 1].len() as u32,+ ))..buffer.anchor_before(point),+ );+ }+ if let Some(bias) = bias {+ state.inlays.push(Inlay::mock_hint(+ row,+ buffer.anchor_at(point, bias),+ ["🇶", "\u{301}", "\t\n\u{600}"][row % 3],+ ));+ }+ }+ let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));+ let expanded = snapshot+ .fold_snapshot()+ .text()+ .split('\n')+ .map(|line| plain_row(line, tab_size))+ .collect::<Vec<_>>();+ assert_eq!(+ snapshot.tab_snapshot().text(),+ expanded+ .iter()+ .map(|row| row.text.as_str())+ .collect::<Vec<_>>()+ .join("\n")+ );+ let raw = snapshot.buffer_snapshot().text();+ let candidates = expanded+ .iter()+ .enumerate()+ .map(|(row, expanded)| {+ enumerated_points(&snapshot, &raw, row as u32, &expanded.boundaries)+ })+ .collect::<Vec<_>>();+ let mut requests = expanded+ .iter()+ .enumerate()+ .flat_map(|(row, expanded)| {+ (0..=expanded.len + 1)+ .chain(iter::once(u32::MAX))+ .flat_map(move |start| {+ [0, start, start.saturating_add(1), expanded.len, u32::MAX]+ .map(|end| (row as u32, start..end))+ })+ })+ .collect::<Vec<_>>();+ requests.extend([(u32::MAX, 0..0), (expanded.len() as u32, 0..1)]);+ requests.extend_from_within(..);+ requests.shuffle(&mut rng);+ let mut query = ColumnarSelectionRows::new(&snapshot);+ for _ in 0..4 {+ let answers = query.points_for_rows(&requests);+ assert_eq!(answers.len(), requests.len());+ for ((row, columns), answer) in requests.iter().zip(answers) {+ let expected = expanded.get(*row as usize).and_then(|expanded| {+ nearest_points(columns, expanded.len, &candidates[*row as usize])+ });+ assert_eq!(+ answer, expected,+ "tab size {tab_size}, bias {bias:?}, row {row}, columns {columns:?}"+ );+ }+ requests.reverse();+ requests = requests.into_iter().step_by(7).collect();+ }+ let points = lines+ .iter()+ .enumerate()+ .flat_map(|(row, line)| {+ scalar_boundaries(line)+ .into_iter()+ .map(move |byte| Point::new(row as u32, byte as u32))+ })+ .collect::<Vec<_>>();+ let mut ranges = points+ .iter()+ .flat_map(|start| points.iter().map(move |end| *start..*end))+ .collect::<Vec<_>>();+ ranges.extend_from_within(..);+ ranges.shuffle(&mut rng);+ let answers = query.columns_for_ranges(&ranges);+ assert_eq!(answers.len(), ranges.len());+ for (range, answer) in ranges.iter().zip(answers) {+ let column = |point| {+ let tab = snapshot+ .tab_snapshot()+ .point_to_tab_point(point, Bias::Left);+ expanded[tab.row() as usize]+ .boundaries+ .partition_point(|byte| *byte <= tab.column() as usize)+ as u32+ - 1+ };+ let start = column(range.start);+ let end = column(range.end);+ assert_eq!(+ answer,+ start.min(end)..start.max(end),+ "tab size {tab_size}, bias {bias:?}, source {range:?}"+ );+ }+ }+ }+ }++ #[test]+ fn test_column_boundaries_across_chunks() {+ for (text, expected) in [+ ("", vec![0]),+ ("abc", vec![0, 1, 2, 3]),+ ("e\u{301}x", vec![0, 3, 4]),+ ("\u{301}\u{301}x", vec![0, 4, 5]),+ ("👩\u{200d}💻x", vec![0, 11, 12]),+ ("🇦🇶🇦🇶🇦x", vec![0, 8, 16, 20, 21]),+ ("क्\u{200d}षx", vec![0, 12, 13]),+ ("\r\nx", vec![0, 2, 3]),+ ("\u{600}🇦🇶🇦x", vec![0, 10, 14, 15]),+ ("🇦\u{301}🇶🇦x", vec![0, 6, 14, 15]),+ ] {+ for split in scalar_boundaries(text) {+ let mut query = RowText::new(+ text.len() as u32,+ ["", &text[..split], "", &text[split..], ""].into_iter(),+ );+ assert_row_boundaries(&mut query, &expected);+ }+ let boundaries = scalar_boundaries(text);+ let mut query = RowText::new(+ text.len() as u32,+ boundaries.windows(2).map(|range| &text[range[0]..range[1]]),+ );+ assert_row_boundaries(&mut query, &expected);+ for start in 0..=text.len() {+ for end in start..=text.len() {+ assert_eq!(+ query.columns_for_bytes(start as u32..end as u32),+ (expected.partition_point(|boundary| *boundary <= start) - 1) as u32+ ..(expected.partition_point(|boundary| *boundary <= end) - 1) as u32,+ "{text:?}, range {start}..{end}"+ );+ }+ }+ }+ }++ #[test]+ fn test_column_boundaries_tab_chunks() {+ let prefix = "\u{600}";+ let suffix = "\u{301}e\u{301}👩\u{200d}💻🇦🇶\0\u{200b}x";+ for width in [1, 4, 128] {+ let spaces = " ".repeat(width);+ let suffix_start = prefix.len() + width;+ let len = suffix_start + suffix.len();+ let expected = iter::once(0)+ .chain(prefix.len()..=suffix_start)+ .chain([2, 5, 16, 24, 25, 28, 29].map(|offset| suffix_start + offset))+ .collect::<Vec<_>>();+ for tab_split in 0..=width {+ for split in scalar_boundaries(suffix) {+ let mut query = RowText::with_tabs(+ len as u32,+ [+ (prefix, false),+ (&spaces[..tab_split], true),+ ("", false),+ (&spaces[tab_split..], true),+ (&suffix[..split], false),+ ("", true),+ (&suffix[split..], false),+ ]+ .into_iter(),+ );+ assert_row_boundaries(&mut query, &expected);+ }+ }+ }+ }++ #[test]+ fn test_column_boundaries_tab_before_large_grapheme() {+ let suffix = format!("{}z", "\u{301}".repeat(1_048_576));+ let mut query = RowText::with_tabs(+ 4 + suffix.len() as u32,+ [(" ", true), (suffix.as_str(), false)].into_iter(),+ );+ let mut cursor = query.cursor(0);+ query.advance_columns(&mut cursor, 4);+ assert_eq!(cursor.byte(), 4);+ let RowText::Unicode(chunks) = &query else {+ panic!("Unicode row")+ };+ assert_eq!(chunks.chunks.len(), 2);+ assert_eq!(chunks.chunks[1].text.as_ptr(), suffix.as_ptr());+ assert_eq!(chunks.context_bytes, 0);+ assert_eq!(query.next_boundary(&mut cursor), Some(2_097_156));+ assert_eq!(query.next_boundary(&mut cursor), Some(2_097_157));+ assert_eq!(query.columns_for_bytes(2_097_155..2_097_155), 4..4);+ query.retreat_to(&mut cursor, 2_097_155);+ assert_eq!(cursor.byte(), 4);+ }++ #[test]+ fn test_row_cursor_forks_and_reverse_floors() {+ let text = "🇦🇶🇦🇶🇦e\u{301}👩\u{200d}💻क्\u{200d}षz";+ let expected = [0, 8, 16, 20, 23, 34, 46, 47];+ let boundaries = scalar_boundaries(text);+ let mut query = RowText::new(+ text.len() as u32,+ boundaries.windows(2).map(|range| &text[range[0]..range[1]]),+ );+ assert_row_boundaries(&mut query, &expected);+ let mut forward = query.cursor(0);+ for pair in expected.windows(2) {+ assert_eq!(forward.byte(), pair[0] as u32);+ let mut backward = forward.clone();+ for byte in (0..pair[0]).rev() {+ query.retreat_to(&mut backward, byte as u32);+ let index = expected.partition_point(|boundary| *boundary <= byte) - 1;+ assert_eq!(backward.byte(), expected[index] as u32);+ }+ assert_eq!(query.next_boundary(&mut forward), Some(pair[1] as u32));+ assert_eq!(backward.byte(), 0);+ }+ }++ #[test]+ fn test_row_cursor_giant_split_clusters() {+ for text in [+ format!("e{}z", "\u{301}".repeat(4096)),+ format!("👩{}\u{200d}💻z", "\u{301}".repeat(4096)),+ format!("क{}षz", "्\u{200d}".repeat(4096)),+ ] {+ let boundaries = scalar_boundaries(&text);+ let mut query = RowText::new(+ text.len() as u32,+ boundaries.windows(2).map(|range| &text[range[0]..range[1]]),+ );+ let end = text.len() as u32;+ let mut cursor = query.cursor(0);+ assert_eq!(query.next_boundary(&mut cursor), Some(end - 1));+ let mut fork = cursor.clone();+ assert_eq!(query.next_boundary(&mut cursor), Some(end));+ assert_eq!(query.previous_boundary(&mut fork), Some(0));+ for byte in [1, end / 2, end - 2] {+ assert_eq!(query.floor_at(byte).byte(), 0);+ }+ assert_eq!(query.floor_at(end - 1).byte(), end - 1);+ assert_eq!(query.previous_boundary(&mut cursor), Some(end - 1));+ assert_eq!(query.previous_boundary(&mut cursor), Some(0));+ let RowText::Unicode(chunks) = &query else {+ panic!("Unicode row")+ };+ assert_eq!(chunks.chunks.len(), boundaries.len() - 1);+ assert_eq!(chunks.chunks[0].text.as_ptr(), text.as_ptr());+ }+ }++ #[test]+ fn test_row_cursor_lazy_polling() {+ let suffix = format!("{}é", "a".repeat(1_048_576));+ let polls = Cell::new(0);+ let chunks = ["éabc", suffix.as_str()].into_iter().inspect(|_| {+ polls.set(polls.get() + 1);+ });+ let mut query = RowText::new(5 + suffix.len() as u32, chunks);+ assert_eq!(query.columns_for_bytes(0..0), 0..0);+ assert_eq!(query.floor_at(0).byte(), 0);+ let mut cursor = query.cursor(0);+ query.advance_columns(&mut cursor, 0);+ assert_eq!(polls.get(), 0);+ query.advance_columns(&mut cursor, 2);+ assert_eq!(cursor.byte(), 3);+ assert_eq!(polls.get(), 1);+ let mut fork = cursor.clone();+ query.retreat_to(&mut fork, 1);+ assert_eq!(fork.byte(), 0);+ assert_eq!(query.next_boundary(&mut cursor), Some(4));+ assert_eq!(polls.get(), 1);+ assert_eq!(query.columns_for_bytes(0..2), 0..1);+ assert_eq!(polls.get(), 1);+ let RowText::Unicode(chunks) = &query else {+ panic!("Unicode row")+ };+ assert_eq!(chunks.chunks.len(), 1);+ assert_eq!(chunks.context_bytes, 0);+ }++ #[test]+ fn test_row_cursor_reverse_regional_context_is_linear() {+ for symbols in [127, 128, 1023, 1024, 8191, 8192] {+ let text = "🇦".repeat(symbols);+ for chunk_symbols in [1, 2, 7, symbols] {+ for end in [text.len(), text.len() - 1, text.len() - 4] {+ let chunks = text.as_bytes().chunks(4 * chunk_symbols).map(|chunk| {+ std::str::from_utf8(chunk).expect("regional indicator chunks")+ });+ let mut query = RowText::new(text.len() as u32, chunks);+ let mut cursor = query.floor_at(end as u32);+ assert_eq!(+ cursor.byte(),+ if end == text.len() { end } else { end / 8 * 8 } as u32+ );+ let mut expected = cursor.byte();+ while expected > 0 {+ expected = (expected - 1) / 8 * 8;+ assert_eq!(query.previous_boundary(&mut cursor), Some(expected));+ }+ assert_eq!(query.previous_boundary(&mut cursor), None);+ let RowText::Unicode(chunks) = &query else {+ panic!("Unicode row")+ };+ if chunk_symbols == 1 {+ assert!(chunks.context_bytes > 0);+ }+ assert!(+ chunks.context_bytes <= text.len() * 2,+ "symbols {symbols}, chunk symbols {chunk_symbols}, end {end}, context bytes {}",+ chunks.context_bytes+ );+ }+ }+ }+ }++ #[gpui::test]+ fn test_columnar_selection_right_inlay_shifts_regional_parity(cx: &mut TestAppContext) {+ init_test(cx);+ for symbols in [4, 64, 8192] {+ let text = format!("{}z", "🇦".repeat(symbols));+ let mut state = plain_state(&text, cx);+ let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));+ state+ .inlays+ .push(Inlay::mock_hint(0, buffer.anchor_after(Point::zero()), "🇶"));+ let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(snapshot.tab_snapshot().text(), format!("🇶{text}"));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ let last_flag = symbols as u32 / 2;+ let requests = (1..=last_flag)+ .flat_map(|column| [(0, column..column), (0, column..last_flag + 1)])+ .collect::<Vec<_>>();+ let end = Point::new(0, symbols as u32 * 4);+ let expected = (1..=last_flag)+ .flat_map(|_| {+ [+ Some((Point::zero(), Point::zero())),+ Some((Point::zero(), end)),+ ]+ })+ .collect::<Vec<_>>();+ assert_batch_points(&mut query, requests, expected, 8 * symbols);+ assert_eq!(+ query.points_for_row(0, &(last_flag..last_flag + 1)),+ Some((Point::zero(), end))+ );+ assert_eq!(+ query.points_for_row(0, &(last_flag + 1..last_flag + 1)),+ Some((end, end))+ );+ }+ }++ #[gpui::test]+ fn test_columnar_selection_tab_control_boundaries(cx: &mut TestAppContext) {+ init_test(cx);+ let expected = plain_row("\t\u{301}x", 4);+ assert_eq!(expected.text, " \u{301}x");+ assert_eq!(expected.len, 6);+ assert_eq!(expected.columns, [(0, 0), (1, 4), (3, 5), (4, 6)]);+ assert_eq!(expected.points, [(0, 0), (4, 1), (5, 3), (6, 4)]);+ assert_eq!(expected.boundaries, [0, 1, 2, 3, 4, 6, 7]);+ for tab_size in [1, 2, 4, 8, 127, 128] {+ set_tab_size(tab_size, cx);+ let after_prepend_tab = 1 + tab_size - 1 % tab_size;+ for (line, endpoints) in [+ (+ "\t\u{301}x",+ vec![(0, 0), (1, tab_size), (3, tab_size + 1), (4, tab_size + 2)],+ ),+ (+ "\u{600}\t\u{301}x",+ vec![+ (0, 0),+ (2, 1),+ (3, after_prepend_tab),+ (5, after_prepend_tab + 1),+ (6, after_prepend_tab + 2),+ ],+ ),+ ] {+ let snapshot = plain_state(&format!("{line}\n{line}"), cx)+ .build_map(cx)+ .update(cx, |map, cx| map.snapshot(cx));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ for source_row in [0, 1] {+ for (index, &(start, start_column)) in endpoints.iter().enumerate() {+ for &(end, end_column) in &endpoints[index..] {+ for reversed in [false, true] {+ let start_point = Point::new(source_row, start);+ let end_point = Point::new(source_row, end);+ let columns = query.columns_for_range(if reversed {+ end_point..start_point+ } else {+ start_point..end_point+ });+ assert_eq!(columns, start_column..end_column);+ let target_row = 1 - source_row;+ assert_eq!(+ query.points_for_row(target_row, &columns),+ Some((+ Point::new(target_row, start),+ Point::new(target_row, end)+ )),+ "line {line:?}, tab size {tab_size}, source row {source_row}, range {start}..{end}, reversed {reversed}"+ );+ }+ }+ }+ }+ assert_plain_rows(&snapshot, tab_size);+ }+ }+ }++ #[gpui::test]+ fn test_columnar_selection_tab_control_boundaries_with_virtual_text(cx: &mut TestAppContext) {+ init_test(cx);+ let mut state = plain_state("\tQx\n\tx", cx);+ let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));+ state.inlays.push(Inlay::mock_hint(+ 0,+ buffer.anchor_after(Point::new(1, 1)),+ "\u{301}",+ ));+ let map = state.build_map(cx);+ map.update(cx, |map, cx| {+ map.fold(+ vec![Crease::simple(+ Point::new(0, 1)..Point::new(0, 2),+ FoldPlaceholder {+ collapsed_text: Some(SharedString::from("\u{301}")),+ ..FoldPlaceholder::test()+ },+ )],+ cx,+ )+ });+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(snapshot.tab_snapshot().text(), " \u{301}x\n \u{301}x");+ let mut query = ColumnarSelectionRows::new(&snapshot);+ for row in [0, 1] {+ assert_eq!(+ query.columns_for_range(Point::new(row, 1)..Point::new(row, 1)),+ 4..4+ );+ assert_eq!(+ query.points_for_row(row, &(4..4)),+ Some((Point::new(row, 1), Point::new(row, 1)))+ );+ assert_eq!(+ query.points_for_row(row, &(4..5)),+ Some((Point::new(row, 1), Point::new(row, 2 - row)))+ );+ }+ }++ #[gpui::test]+ fn test_columnar_selection_lazy_unicode_prefix(cx: &mut TestAppContext) {+ init_test(cx);+ let line = format!("{}é", "a".repeat(1_048_576));+ let snapshot = plain_state(&format!("{line}\n{line}"), cx)+ .build_map(cx)+ .update(cx, |map, cx| map.snapshot(cx));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ assert_eq!(query.columns_for_range(Point::zero()..Point::zero()), 0..0);+ assert_eq!(+ query.points_for_row(1, &(0..0)),+ Some((Point::new(1, 0), Point::new(1, 0)))+ );+ for row in [query.row(1), query.buffer_row(1)] {+ let RowText::Unicode(chunks) = row else {+ panic!("Unicode row")+ };+ assert_eq!(chunks.chunks.len(), 0);+ }+ assert_eq!(+ query.points_for_row(1, &(1..1)),+ Some((Point::new(1, 1), Point::new(1, 1)))+ );+ for mut row in [query.row(1), query.buffer_row(1)] {+ let mut cursor = row.cursor(0);+ row.advance_columns(&mut cursor, 1);+ assert_eq!(cursor.byte(), 1);+ let RowText::Unicode(chunks) = row else {+ panic!("Unicode row")+ };+ assert_eq!(chunks.chunks.len(), 1);+ }+ assert_eq!(+ query.points_for_row(1, &(1_048_576..1_048_576)),+ Some((Point::new(1, 1_048_576), Point::new(1, 1_048_576)))+ );+ }++ #[gpui::test]+ fn test_columnar_selection_skips_long_virtual_row(cx: &mut TestAppContext) {+ init_test(cx);+ let mut state = plain_state(&format!("x\n{}", "a".repeat(1_048_576)), cx);+ let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));+ state.inlays.push(Inlay::mock_hint(+ 0,+ buffer.anchor_before(Point::new(1, 0)),+ &format!("{}\n", "a".repeat(1_048_576)),+ ));+ let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ assert_eq!(query.points_for_row(1, &(1_048_576..1_048_576)), None);+ assert_eq!(+ query.points_for_row(2, &(1_048_576..1_048_576)),+ Some((Point::new(1, 1_048_576), Point::new(1, 1_048_576)))+ );+ }++ #[gpui::test]+ fn test_columnar_selection_graphemes_and_edges(cx: &mut TestAppContext) {+ init_test(cx);+ let state = plain_state("e\u{301}\néé\n\n\t\u{301}x\n👩\u{200d}💻z\n", cx);+ let map = state.build_map(cx);+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ assert_eq!(+ query.columns_for_range(Point::new(0, 0)..Point::new(0, 3)),+ 0..1+ );+ assert_eq!(+ query.columns_for_range(Point::new(1, 0)..Point::new(1, 4)),+ 0..2+ );+ assert_eq!(+ query.columns_for_range(Point::new(1, 4)..Point::new(0, 0)),+ 0..2+ );+ assert_eq!(+ query.points_for_row(0, &(0..1)),+ Some((Point::new(0, 0), Point::new(0, 3)))+ );+ assert_eq!(+ query.points_for_row(1, &(0..1)),+ Some((Point::new(1, 0), Point::new(1, 2)))+ );+ assert_eq!(query.points_for_row(0, &(1..2)), None);+ assert_eq!(+ query.points_for_row(0, &(u32::MAX..u32::MAX)),+ Some((Point::new(0, 3), Point::new(0, 3)))+ );+ assert_eq!(+ query.points_for_row(2, &(0..0)),+ Some((Point::new(2, 0), Point::new(2, 0)))+ );+ assert_eq!(query.points_for_row(2, &(0..1)), None);+ assert_eq!(+ query.points_for_row(3, &(3..4)),+ Some((Point::new(3, 0), Point::new(3, 1)))+ );+ assert_eq!(+ query.points_for_row(4, &(0..1)),+ Some((Point::new(4, 0), Point::new(4, 11)))+ );+ assert_eq!(+ query.points_for_row(5, &(u32::MAX..u32::MAX)),+ Some((Point::new(5, 0), Point::new(5, 0)))+ );+ assert_eq!(query.points_for_row(6, &(0..0)), None);+ assert_eq!(query.points_for_row(u32::MAX, &(0..0)), None);+ assert_plain_rows(&snapshot, 4);+ let empty = plain_state("", cx)+ .build_map(cx)+ .update(cx, |map, cx| map.snapshot(cx));+ assert_plain_rows(&empty, 4);+ }++ #[gpui::test]+ fn test_columnar_selection_ascii_fast_path(cx: &mut TestAppContext) {+ init_test(cx);+ let state = plain_state(&format!("{}\nx", "a".repeat(1_048_576)), cx);+ let map = state.build_map(cx);+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ assert_eq!(query.points_for_row(1, &(2..3)), None);+ assert_eq!(size_of_val(&query), size_of::<&DisplaySnapshot>());+ assert_eq!(+ query.columns_for_range(Point::zero()..Point::new(0, 1_048_576)),+ 0..1_048_576+ );+ let RowText::Ascii(len) = query.row(0) else {+ panic!("ASCII row allocated Unicode boundaries")+ };+ assert_eq!(len, 1_048_576);+ assert_eq!(+ query.points_for_row(0, &(1_048_575..u32::MAX)),+ Some((Point::new(0, 1_048_575), Point::new(0, 1_048_576)))+ );+ let RowText::Ascii(len) = query.buffer_row(0) else {+ panic!("ASCII buffer row allocated Unicode boundaries")+ };+ assert_eq!(len, 1_048_576);+ }++ #[gpui::test]+ fn test_columnar_selection_tab_expansion_boundary(cx: &mut TestAppContext) {+ init_test(cx);+ let prefixes = (255..=257)+ .map(|column| format!("{}{}", "α".repeat(127), "a".repeat(column - 254)))+ .chain([+ format!("{}α", "a".repeat(255)),+ format!("{}e\u{301}", "a".repeat(254)),+ ])+ .collect::<Vec<_>>();+ let text = prefixes+ .iter()+ .map(|prefix| format!("{prefix}\t\u{301}β"))+ .collect::<Vec<_>>()+ .join("\n");+ let buffer = cx.new(|cx| Buffer::local(text, cx));+ let state = MapState::new(cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx)));+ let map = state.build_map(cx);+ for tab_size in [1, 3, 128] {+ set_tab_size(tab_size, cx);+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ assert_plain_rows(&snapshot, tab_size);+ if tab_size == 128 {+ assert_eq!(+ snapshot.tab_snapshot().text(),+ format!(+ "{}{}\u{301}β\n{} \u{301}β\n{} \u{301}β\n{} \u{301}β\n{} \u{301}β",+ prefixes[0],+ " ".repeat(128),+ prefixes[1],+ prefixes[2],+ prefixes[3],+ prefixes[4]+ )+ );+ }+ buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "a")], None, cx));+ assert_plain_rows(&map.update(cx, |map, cx| map.snapshot(cx)), tab_size);+ buffer.update(cx, |buffer, cx| buffer.edit([(0..1, "")], None, cx));+ let restored = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(+ restored.tab_snapshot().text(),+ snapshot.tab_snapshot().text()+ );+ assert_plain_rows(&restored, tab_size);+ }+ }++ #[gpui::test]+ fn test_columnar_selection_folds_and_inlays_without_frames(+ cx: &mut TestAppContext,+ mut rng: StdRng,+ ) {+ init_test(cx);+ let mut state = plain_state("e\u{301}x\nab\ncd", cx);+ let map = state.build_map(cx);+ map.update(cx, |map, cx| {+ map.fold(+ vec![Crease::simple(+ Point::new(0, 1)..Point::new(0, 3),+ FoldPlaceholder::test(),+ )],+ cx,+ )+ });+ let folded = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(folded.tab_snapshot().text(), "e⋯x\nab\ncd");+ assert_eq!(+ ColumnarSelectionRows::new(&folded).points_for_row(0, &(1..2)),+ Some((Point::new(0, 0), Point::new(0, 3)))+ );+ state.folds = folded+ .folds_in_range(Anchor::Min..Anchor::Max)+ .map(|fold| fold.range.0.clone())+ .collect();+ for (index, bias) in [Bias::Left, Bias::Right].into_iter().enumerate() {+ state.inlays.push(Inlay::mock_hint(+ index,+ folded.buffer_snapshot().anchor_at(Point::new(1, 1), bias),+ "\u{301}\n\tR",+ ));+ }+ map.update(cx, |map, cx| {+ map.splice_inlays(&[], state.inlays.clone(), cx)+ });+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(+ snapshot.tab_snapshot().text(),+ "e⋯x\na\u{301}\n R\u{301}\n Rb\ncd"+ );+ let mut query = ColumnarSelectionRows::new(&snapshot);+ assert_eq!(query.points_for_row(2, &(0..0)), None);+ assert_eq!(query.points_for_row(2, &(0..u32::MAX)), None);+ let rebuilt = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));+ check_snapshot(&snapshot, &rebuilt, true, None, 4, &mut rng, 0);+ }++ #[gpui::test]+ fn test_columnar_selection_long_fold_placeholders(cx: &mut TestAppContext) {+ init_test(cx);+ for placeholder in ["...", "long placeholder", "ééé", "👩\u{200d}💻xyz"] {+ for edited in [false, true] {+ let buffer = cx.new(|cx| Buffer::local(if edited { "a\nxb" } else { "axb" }, cx));+ let state = MapState::new(cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx)));+ let map = state.build_map(cx);+ map.update(cx, |map, cx| {+ map.fold(+ vec![Crease::simple(+ Point::new(0, 1)..if edited {+ Point::new(1, 1)+ } else {+ Point::new(0, 2)+ },+ FoldPlaceholder {+ collapsed_text: Some(SharedString::from(placeholder)),+ ..FoldPlaceholder::test()+ },+ )],+ cx,+ );+ });+ if edited {+ buffer.update(cx, |buffer, cx| {+ buffer.edit([(Point::new(0, 1)..Point::new(1, 0), "")], None, cx)+ });+ }+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(snapshot.tab_snapshot().text(), format!("a{placeholder}b"));+ let mut query = ColumnarSelectionRows::new(&snapshot);+ let end = 1 + placeholder.graphemes(true).count() as u32;+ for column in 1..end {+ assert_eq!(+ query.points_for_row(0, &(column..column)),+ Some((Point::new(0, 1), Point::new(0, 1))),+ "{placeholder:?}, column {column}, edited {edited}"+ );+ }+ assert_eq!(+ query.points_for_row(0, &(end..end)),+ Some((Point::new(0, 2), Point::new(0, 2)))+ );+ }+ }+ }++ #[gpui::test]+ fn test_columnar_selection_fold_grapheme_edges(cx: &mut TestAppContext) {+ init_test(cx);+ for (text, placeholder, column, expected) in+ [("axb", "\u{301}..", 1, 0), ("ax\u{301}b", "..", 3, 4)]+ {+ let state = plain_state(text, cx);+ let map = state.build_map(cx);+ map.update(cx, |map, cx| {+ map.fold(+ vec![Crease::simple(+ Point::new(0, 1)..Point::new(0, 2),+ FoldPlaceholder {+ collapsed_text: Some(SharedString::from(placeholder)),+ ..FoldPlaceholder::test()+ },+ )],+ cx,+ )+ });+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(+ ColumnarSelectionRows::new(&snapshot).points_for_row(0, &(column..column)),+ Some((Point::new(0, expected), Point::new(0, expected))),+ "{text:?}, {placeholder:?}"+ );+ }+ for merge in [false, true] {+ let map = plain_state("axyb", cx).build_map(cx);+ map.update(cx, |map, cx| {+ map.fold(+ [(1, ".."), (2, "ZZ")]+ .into_iter()+ .map(|(start, placeholder)| {+ Crease::simple(+ Point::new(0, start)..Point::new(0, start + 1),+ FoldPlaceholder {+ merge_adjacent: merge,+ collapsed_text: Some(SharedString::from(placeholder)),+ ..FoldPlaceholder::test()+ },+ )+ })+ .collect(),+ cx,+ )+ });+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(+ snapshot.tab_snapshot().text(),+ if merge { "a..b" } else { "a..ZZb" }+ );+ let expected = if merge {+ vec![0, 1, 1, 3, 4]+ } else {+ vec![0, 1, 1, 2, 2, 3, 4]+ };+ let mut query = ColumnarSelectionRows::new(&snapshot);+ for (column, byte) in expected.into_iter().enumerate() {+ let column = column as u32;+ assert_eq!(+ query.points_for_row(0, &(column..column)),+ Some((Point::new(0, byte), Point::new(0, byte))),+ "merge={merge}, column={column}"+ );+ }+ }+ }++ #[gpui::test]+ fn test_columnar_selection_fold_ending_inside_grapheme(cx: &mut TestAppContext) {+ init_test(cx);+ let map = plain_state("aX\u{1100}\u{1161}z", cx).build_map(cx);+ map.update(cx, |map, cx| {+ map.fold(+ vec![Crease::simple(+ Point::new(0, 1)..Point::new(0, 5),+ FoldPlaceholder::test(),+ )],+ cx,+ )+ });+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(snapshot.tab_snapshot().text(), "a⋯\u{1161}z");+ let mut query = ColumnarSelectionRows::new(&snapshot);+ for (columns, expected) in [+ (0..0, (Point::new(0, 0), Point::new(0, 0))),+ (1..1, (Point::new(0, 1), Point::new(0, 1))),+ (2..2, (Point::new(0, 1), Point::new(0, 1))),+ (3..3, (Point::new(0, 8), Point::new(0, 8))),+ (4..4, (Point::new(0, 9), Point::new(0, 9))),+ (1..3, (Point::new(0, 1), Point::new(0, 8))),+ (2..4, (Point::new(0, 1), Point::new(0, 9))),+ ] {+ assert_eq!(+ query.points_for_row(0, &columns),+ Some(expected),+ "columns {columns:?}"+ );+ }+ }++ #[test]+ fn test_column_boundaries_large_grapheme() {+ let text = format!("e{}z", "\u{301}".repeat(1024));+ let mut query = RowText::new(text.len() as u32, iter::once(text.as_str()));+ let mut cursor = query.cursor(0);+ assert_eq!(cursor.byte(), 0);+ assert_eq!(query.next_boundary(&mut cursor), Some(2049));+ assert_eq!(query.next_boundary(&mut cursor), Some(2050));+ assert_eq!(query.columns_for_bytes(2048..2049), 0..1);+ assert_eq!(query.floor_at(2048).byte(), 0);+ assert_eq!(query.floor_at(2049).byte(), 2049);+ }++ #[gpui::test(iterations = 20)]+ fn test_columnar_selection_during_pending_rewrap(cx: &mut TestAppContext, mut rng: StdRng) {+ init_test(cx);+ cx.background_executor.set_block_on_ticks(0..=0);+ let text = (0..120)+ .map(|row| format!("row{row} {}", random_text(&mut rng, 6)))+ .collect::<Vec<_>>()+ .join("\n");+ let mut state = plain_state(&text, cx);+ let map = state.build_map(cx);+ let snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ let buffer = snapshot.buffer_snapshot();+ let hidden_start = rng.random_range(0..buffer.max_point().row);+ let hidden_end = rng.random_range(hidden_start..=buffer.max_point().row);+ state.block = Some((+ BlockPlacement::Replace(+ buffer.anchor_before(Point::new(hidden_start, 0))+ ..=buffer.anchor_after(Point::new(+ hidden_end,+ buffer.line_len(MultiBufferRow(hidden_end)),+ )),+ ),+ 1,+ ));+ map.update(cx, |map, cx| {+ map.insert_blocks([state.block_properties().expect("block")], cx)+ });+ state.wrap_width = Some(px(30.0));+ map.update(cx, |map, cx| map.set_wrap_width(state.wrap_width, cx));+ assert!(map.update(cx, |map, cx| map.is_rewrapping(cx)));+ let interpolated = map.update(cx, |map, cx| map.snapshot(cx));+ assert!(map.update(cx, |map, cx| map.is_rewrapping(cx)));+ check_snapshot(&interpolated, &interpolated, true, None, 4, &mut rng, 0);+ let rebuilt = state.build_map(cx);+ cx.run_until_parked();+ assert!(!map.update(cx, |map, cx| map.is_rewrapping(cx)));+ let rebuilt = rebuilt.update(cx, |map, cx| map.snapshot(cx));+ let settled = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(hidden_rows(&settled), hidden_rows(&rebuilt));+ check_snapshot(&settled, &rebuilt, true, None, 4, &mut rng, 1);+ check_snapshot(+ &interpolated,+ &settled,+ hidden_rows(&interpolated) == hidden_rows(&settled),+ None,+ 4,+ &mut rng,+ 2,+ );+ }++ #[gpui::test(iterations = 100)]+ fn test_random_columnar_selections(cx: &mut TestAppContext, mut rng: StdRng) {+ init_test(cx);+ cx.background_executor.set_block_on_ticks(0..=50);+ let operations = env::var("OPERATIONS")+ .map(|value| value.parse::<usize>().expect("invalid OPERATIONS"))+ .unwrap_or(15);+ let mut texts = (0..rng.random_range(1..=2))+ .map(|_| format!("a{}z", random_text(&mut rng, 12)))+ .collect::<Vec<_>>();+ let buffers = texts+ .iter()+ .map(|text| cx.new(|cx| Buffer::local(text.clone(), cx)))+ .collect::<Vec<_>>();+ let multibuffer = cx.new(|cx| {+ if buffers.len() == 1 {+ return MultiBuffer::singleton(buffers[0].clone(), cx);+ }+ let mut buffer = MultiBuffer::new(Capability::ReadWrite);+ for (index, source) in buffers.iter().enumerate() {+ let snapshot = source.read(cx).snapshot();+ buffer.set_excerpt_ranges_for_path(+ PathKey::sorted(index as u64),+ source.clone(),+ &snapshot,+ vec![ExcerptRange::new(Point::zero()..snapshot.max_point())],+ cx,+ );+ }+ buffer+ });+ let mut state = MapState::new(multibuffer);+ let map = state.build_map(cx);+ let mut block_ids = HashSet::default();+ let mut kinds = [0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6];+ kinds.shuffle(&mut rng);+ let mut snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ check_snapshot(+ &snapshot,+ &snapshot,+ true,+ Some(&texts.join("\n")),+ 4,+ &mut rng,+ 0,+ );+ for operation in 0..operations {+ let kind = kinds[operation % kinds.len()];+ log::info!(+ "operation {operation}: kind {kind}, texts {texts:?}, tabs {}, folds {:?}, inlays {:?}, block {:?}, wrap {:?}",+ state.tab_size,+ state.folds,+ state.inlays,+ state.block,+ state.wrap_width+ );+ let replaced_before = state.replaces_rows();+ match kind {+ 0 => {+ let index = rng.random_range(0..buffers.len());+ let text = &mut texts[index];+ let boundaries = text+ .char_indices()+ .map(|(offset, _)| offset)+ .skip(1)+ .collect::<Vec<_>>();+ let start = rng.random_range(0..boundaries.len());+ let mut range =+ boundaries[start]..boundaries[rng.random_range(start..boundaries.len())];+ let mut replacement = random_text(&mut rng, 4);+ if text.get(range.clone()) == Some(replacement.as_str()) {+ replacement.push('a');+ }+ let mut expected = text.clone();+ expected.replace_range(range.clone(), &replacement);+ if expected.len() > 256+ || expected.matches('\t').count() > 4+ || expected.matches('\n').count() > 12+ {+ range = 1..text.len() - 1;+ replacement.clear();+ expected = String::from("az");+ }+ assert_ne!(expected.as_str(), text.as_str());+ log::info!("edit buffer {index}: {range:?} -> {replacement:?}");+ buffers[index].update(cx, |buffer, cx| {+ buffer.edit([(range, replacement)], None, cx)+ });+ *text = expected;+ if state.replaces_rows() {+ map.update(cx, |map, cx| {+ map.remove_blocks(std::mem::take(&mut block_ids), cx);+ block_ids.extend(+ map.insert_blocks([state.block_properties().expect("block")], cx),+ );+ });+ }+ }+ 1 => {+ let size = rng.random_range(1..128);+ state.tab_size = size + u32::from(size >= state.tab_size);+ set_tab_size(state.tab_size, cx);+ }+ 2 => {+ if state.folds.is_empty() {+ let index = rng.random_range(0..texts.len());+ let base = texts+ .iter()+ .take(index)+ .map(|text| text.len() + 1)+ .sum::<usize>();+ let boundaries = scalar_boundaries(&texts[index]);+ let start = rng.random_range(0..boundaries.len() - 1);+ let end = rng.random_range(start + 1..boundaries.len());+ let buffer = snapshot.buffer_snapshot();+ let range = buffer.anchor_after(MultiBufferOffset(base + boundaries[start]))+ ..buffer.anchor_before(MultiBufferOffset(base + boundaries[end]));+ map.update(cx, |map, cx| {+ map.fold(vec![Crease::simple(range, FoldPlaceholder::test())], cx)+ });+ } else {+ map.update(cx, |map, cx| {+ map.unfold_intersecting([Anchor::Min..Anchor::Max], true, cx)+ });+ if state.replaces_rows() {+ block_ids.clear();+ state.block = None;+ }+ }+ }+ 3 | 6 => {+ if state.inlays.is_empty() {+ let text = snapshot.buffer_snapshot().text();+ let boundaries = scalar_boundaries(&text);+ let offset =+ MultiBufferOffset(boundaries[rng.random_range(0..boundaries.len())]);+ for (index, bias) in [Bias::Left, Bias::Right].into_iter().enumerate() {+ let text = format!("\n{}\t", random_text(&mut rng, 3));+ state.inlays.push(Inlay::mock_hint(+ index,+ snapshot.buffer_snapshot().anchor_at(offset, bias),+ text.as_str(),+ ));+ }+ map.update(cx, |map, cx| {+ map.splice_inlays(&[], state.inlays.clone(), cx)+ });+ } else {+ let ids = state+ .inlays+ .iter()+ .map(|inlay| inlay.id)+ .collect::<Vec<_>>();+ map.update(cx, |map, cx| map.splice_inlays(&ids, Vec::new(), cx));+ state.inlays.clear();+ }+ }+ 4 => {+ state.wrap_width = if state.wrap_width.is_some() {+ None+ } else {+ Some(px([0.0, 12.0, 48.0, 300.0][rng.random_range(0..4)]))+ };+ map.update(cx, |map, cx| map.set_wrap_width(state.wrap_width, cx));+ }+ 5 => {+ if state.block.is_some() {+ map.update(cx, |map, cx| {+ map.remove_blocks(std::mem::take(&mut block_ids), cx)+ });+ state.block = None;+ } else {+ let text = snapshot.buffer_snapshot().text();+ let boundaries = scalar_boundaries(&text);+ let start = rng.random_range(0..boundaries.len());+ let buffer = snapshot.buffer_snapshot();+ let position = buffer.anchor_after(MultiBufferOffset(boundaries[start]));+ let placement = match rng.random_range(0..3) {+ 0 => BlockPlacement::Above(position),+ 1 => BlockPlacement::Below(position),+ _ => {+ let start = rng.random_range(0..boundaries.len() - 1);+ let end = rng.random_range(start + 1..boundaries.len());+ BlockPlacement::Replace(+ buffer.anchor_before(MultiBufferOffset(boundaries[start]))+ ..=buffer.anchor_after(MultiBufferOffset(boundaries[end])),+ )+ }+ };+ state.block = Some((placement, rng.random_range(1..=3)));+ block_ids.extend(map.update(cx, |map, cx| {+ map.insert_blocks([state.block_properties().expect("block")], cx)+ }));+ }+ }+ _ => unreachable!(),+ }+ let previous = snapshot;+ snapshot = map.update(cx, |map, cx| map.snapshot(cx));+ state.folds = snapshot+ .folds_in_range(Anchor::Min..Anchor::Max)+ .map(|fold| fold.range.0.clone())+ .collect();+ let text = texts.join("\n");+ assert_eq!(+ snapshot.buffer_snapshot().text(),+ text,+ "operation {operation}"+ );+ let plain = (state.folds.is_empty()+ && state+ .inlays+ .iter()+ .all(|inlay| !inlay.position.is_valid(snapshot.buffer_snapshot()))+ && !state.replaces_rows())+ .then_some(text.as_str());+ let rewrapping = map.update(cx, |map, cx| map.is_rewrapping(cx));+ let rebuilt = state.build_map(cx);+ cx.run_until_parked();+ let rebuilt = rebuilt.update(cx, |map, cx| map.snapshot(cx));+ let settled = map.update(cx, |map, cx| map.snapshot(cx));+ assert_eq!(+ hidden_rows(&settled),+ hidden_rows(&rebuilt),+ "operation {operation}: hidden rows"+ );+ check_snapshot(+ &snapshot,+ &rebuilt,+ !state.replaces_rows() || !rewrapping,+ plain,+ state.tab_size,+ &mut rng,+ operation,+ );+ if (kind == 4 || kind == 5) && !replaced_before && !state.replaces_rows() {+ check_snapshot(+ &snapshot,+ &previous,+ true,+ plain,+ state.tab_size,+ &mut rng,+ operation,+ );+ }+ check_snapshot(+ &settled,+ &rebuilt,+ true,+ plain,+ state.tab_size,+ &mut rng,+ operation,+ );+ snapshot = settled;+ }+ }++ struct MapState {+ buffer: Entity<MultiBuffer>,+ tab_size: u32,+ folds: Vec<Range<Anchor>>,+ inlays: Vec<Inlay>,+ block: Option<(BlockPlacement<Anchor>, u32)>,+ wrap_width: Option<Pixels>,+ }++ impl MapState {+ fn new(buffer: Entity<MultiBuffer>) -> Self {+ Self {+ buffer,+ tab_size: 4,+ folds: Vec::new(),+ inlays: Vec::new(),+ block: None,+ wrap_width: None,+ }+ }++ fn build_map(&self, cx: &mut TestAppContext) -> Entity<DisplayMap> {+ cx.new(|cx| {+ let mut map = DisplayMap::new(+ self.buffer.clone(),+ test_font(),+ px(10.0),+ self.wrap_width,+ 1,+ 1,+ FoldPlaceholder::test(),+ DiagnosticSeverity::Warning,+ cx,+ );+ map.splice_inlays(&[], self.inlays.clone(), cx);+ if !self.folds.is_empty() {+ map.fold(+ self.folds+ .iter()+ .cloned()+ .map(|range| Crease::simple(range, FoldPlaceholder::test()))+ .collect(),+ cx,+ );+ }+ if let Some(block) = self.block_properties() {+ map.insert_blocks([block], cx);+ }+ map+ })+ }++ fn replaces_rows(&self) -> bool {+ matches!(self.block, Some((BlockPlacement::Replace(_), _)))+ }++ fn block_properties(&self) -> Option<BlockProperties<Anchor>> {+ self.block+ .as_ref()+ .map(|(placement, height)| BlockProperties {+ placement: placement.clone(),+ style: BlockStyle::Fixed,+ height: Some(*height),+ render: Arc::new(|_| div().into_any()),+ priority: 0,+ })+ }+ }++ struct PlainRow {+ text: String,+ len: u32,+ columns: Vec<(u32, u32)>,+ points: Vec<(u32, u32)>,+ boundaries: Vec<usize>,+ }++ fn assert_batch_points(+ query: &mut ColumnarSelectionRows<'_>,+ mut requests: Vec<(u32, Range<u32>)>,+ mut expected: Vec<Option<(Point, Point)>>,+ work_bound: usize,+ ) {+ for _ in 0..2 {+ ROW_WORK.set((0, 0));+ let answers = query.points_for_rows(&requests);+ assert_eq!(answers.len(), expected.len());+ for (index, (answer, expected)) in answers.iter().zip(&expected).enumerate() {+ assert_eq!(answer, expected, "request {index}: {:?}", requests[index]);+ }+ let (boundaries, chunks) = ROW_WORK.get();+ assert!(boundaries <= work_bound, "{boundaries} > {work_bound}");+ assert!(chunks <= work_bound, "{chunks} > {work_bound}");+ requests.reverse();+ expected.reverse();+ }+ }++ fn enumerated_points(+ snapshot: &DisplaySnapshot,+ raw: &str,+ row: u32,+ boundaries: &[usize],+ ) -> Vec<(u32, Point)> {+ raw.split('\n')+ .enumerate()+ .flat_map(|(row, line)| {+ grapheme_boundaries(line)+ .into_iter()+ .map(move |byte| Point::new(row as u32, byte as u32))+ })+ .filter_map(|point| {+ let tab = snapshot+ .tab_snapshot()+ .point_to_tab_point(point, Bias::Left);+ if tab.row() != row+ || snapshot.tab_snapshot().tab_point_to_point(tab, Bias::Left) != point+ {+ return None;+ }+ let display = point.to_display_point(snapshot);+ if display.to_point(snapshot) != point || snapshot.is_block_line(display.row()) {+ return None;+ }+ boundaries+ .binary_search(&(tab.column() as usize))+ .ok()+ .map(|column| (column as u32, point))+ })+ .collect()+ }++ fn nearest_points(+ columns: &Range<u32>,+ length: u32,+ candidates: &[(u32, Point)],+ ) -> Option<(Point, Point)> {+ if columns.start > columns.end || (columns.start != columns.end && columns.start >= length)+ {+ return None;+ }+ let point = |column| {+ candidates+ .iter()+ .filter(|(candidate, _)| *candidate <= column)+ .max_by_key(|(candidate, _)| *candidate)+ .map(|(_, point)| *point)+ };+ point(columns.start).zip(point(columns.end))+ }++ fn hidden_rows(snapshot: &DisplaySnapshot) -> Vec<bool> {+ (0..=snapshot.buffer_snapshot().max_point().row)+ .map(|row| snapshot.is_block_line(Point::new(row, 0).to_display_point(snapshot).row()))+ .collect()+ }++ fn init_test(cx: &mut TestAppContext) {+ cx.update(|cx| {+ let settings = SettingsStore::test(cx);+ cx.set_global(settings);+ crate::init(cx);+ theme_settings::init(LoadThemes::JustBase, cx);+ });+ set_tab_size(4, cx);+ }++ fn set_tab_size(size: u32, cx: &mut TestAppContext) {+ cx.update(|cx| {+ cx.update_global::<SettingsStore, _>(|store, cx| {+ store.update_user_settings(cx, |settings| {+ settings.project.all_languages.defaults.tab_size = NonZeroU32::new(size);+ })+ })+ });+ }++ fn plain_state(text: &str, cx: &mut TestAppContext) -> MapState {+ MapState::new(cx.update(|cx| MultiBuffer::build_simple(text, cx)))+ }++ fn random_text(rng: &mut StdRng, tokens: usize) -> String {+ let mut text = String::new();+ let mut tabs = 0;+ for _ in 0..rng.random_range(0..=tokens) {+ let mut token = *[+ "a",+ " ",+ "\t",+ "\n",+ "α",+ "界",+ "🏀",+ "é",+ "e\u{301}",+ "o\u{308}\u{301}",+ "\u{301}",+ "👩\u{200d}💻",+ "👍🏽",+ "🇦🇶",+ "✈\u{fe0f}",+ ]+ .choose(rng)+ .expect("tokens");+ if token == "\t" {+ if tabs == 2 {+ token = "a";+ } else {+ tabs += 1;+ }+ }+ text.push_str(token);+ }+ text+ }++ fn assert_row_boundaries(query: &mut RowText<'_>, expected: &[usize]) {+ let length = *expected.last().expect("end boundary");+ for byte in 0..=length + 1 {+ let column = expected.partition_point(|boundary| *boundary <= byte) - 1;+ assert_eq!(+ query.columns_for_bytes(byte as u32..byte as u32),+ column as u32..column as u32,+ "byte {byte}, expected {expected:?}"+ );+ assert_eq!(+ query.floor_at(byte as u32).byte(),+ expected[column] as u32,+ "byte {byte}, expected {expected:?}"+ );+ }+ let mut cursor = query.cursor(0);+ for byte in expected.iter().skip(1) {+ assert_eq!(query.next_boundary(&mut cursor), Some(*byte as u32));+ }+ assert_eq!(query.next_boundary(&mut cursor), None);+ for byte in expected.iter().rev().skip(1) {+ assert_eq!(query.previous_boundary(&mut cursor), Some(*byte as u32));+ }+ assert_eq!(query.previous_boundary(&mut cursor), None);+ let mut cursor = query.floor_at(u32::MAX);+ assert_eq!(cursor.byte(), length as u32);+ for byte in expected.iter().rev().skip(1) {+ assert_eq!(query.previous_boundary(&mut cursor), Some(*byte as u32));+ }+ query.advance_columns(&mut cursor, u32::MAX);+ assert_eq!(cursor.byte(), length as u32);+ }++ fn scalar_boundaries(text: &str) -> Vec<usize> {+ text.char_indices()+ .map(|(offset, _)| offset)+ .chain(iter::once(text.len()))+ .collect()+ }++ fn grapheme_boundaries(text: &str) -> Vec<usize> {+ text.grapheme_indices(true)+ .map(|(offset, _)| offset)+ .chain(iter::once(text.len()))+ .collect()+ }++ fn plain_row(line: &str, tab_size: u32) -> PlainRow {+ let mut text = String::new();+ let mut columns = Vec::new();+ let mut points = Vec::new();+ let mut boundaries = Vec::new();+ let mut column = 0;+ let mut character_column = 0;+ for (byte, grapheme) in line.grapheme_indices(true) {+ points.push((column, byte as u32));+ columns.extend(+ grapheme+ .char_indices()+ .map(|(offset, _)| ((byte + offset) as u32, column)),+ );+ if grapheme == "\t" {+ let width = if byte < 256 {+ tab_size - character_column % tab_size+ } else {+ 1+ };+ boundaries.extend(text.len()..text.len() + width as usize);+ text.extend(iter::repeat_n(' ', width as usize));+ character_column += width;+ column += width;+ } else {+ boundaries.push(text.len());+ text.push_str(grapheme);+ character_column += grapheme.chars().count() as u32;+ column += 1;+ }+ }+ columns.push((line.len() as u32, column));+ points.push((column, line.len() as u32));+ boundaries.push(text.len());+ PlainRow {+ text,+ len: column,+ columns,+ points,+ boundaries,+ }+ }++ fn expected_points(+ row: u32,+ columns: &Range<u32>,+ expected: &PlainRow,+ ) -> Option<(Point, Point)> {+ if columns.start != columns.end && columns.start >= expected.len {+ return None;+ }+ let point = |column| {+ Point::new(+ row,+ expected+ .points+ .iter()+ .rev()+ .find(|(candidate, _)| *candidate <= column)+ .expect("row start")+ .1,+ )+ };+ Some((point(columns.start), point(columns.end)))+ }++ fn assert_plain_rows(snapshot: &DisplaySnapshot, tab_size: u32) {+ let raw = snapshot.buffer_snapshot().text();+ let expected = raw+ .split('\n')+ .map(|line| plain_row(line, tab_size))+ .collect::<Vec<_>>();+ assert_eq!(+ snapshot.tab_snapshot().text(),+ expected+ .iter()+ .map(|row| row.text.as_str())+ .collect::<Vec<_>>()+ .join("\n")+ );+ let mut query = ColumnarSelectionRows::new(snapshot);+ for (row, expected) in expected.iter().enumerate() {+ let row = row as u32;+ assert_eq!(+ query.row(row).columns_for_bytes(0..u32::MAX).end,+ expected.len+ );+ for &(byte, column) in &expected.columns {+ assert_eq!(+ query.columns_for_range(Point::new(row, byte)..Point::new(row, byte)),+ column..column+ );+ }+ for column in 0..=expected.len + 1 {+ for columns in [column..column, column..column + 1, column..u32::MAX] {+ assert_eq!(+ query.points_for_row(row, &columns),+ expected_points(row, &columns, expected),+ "row {row}, columns {columns:?}, text {:?}",+ expected.text+ );+ }+ }+ }+ }++ fn check_snapshot(+ snapshot: &DisplaySnapshot,+ rebuilt: &DisplaySnapshot,+ blocks_agree: bool,+ plain: Option<&str>,+ tab_size: u32,+ rng: &mut StdRng,+ operation: usize,+ ) {+ let text = snapshot.tab_snapshot().text();+ assert_eq!(+ text,+ rebuilt.tab_snapshot().text(),+ "operation {operation}: tab text"+ );+ assert_eq!(+ snapshot.fold_snapshot().text(),+ rebuilt.fold_snapshot().text(),+ "operation {operation}: fold text"+ );+ assert_eq!(+ snapshot.inlay_snapshot().text(),+ rebuilt.inlay_snapshot().text(),+ "operation {operation}: inlay text"+ );+ let raw = snapshot.buffer_snapshot().text();+ assert_eq!(raw, rebuilt.buffer_snapshot().text());+ if let Some(plain) = plain {+ assert_eq!(raw, plain);+ }+ let expected = plain.map(|plain| {+ plain+ .split('\n')+ .map(|line| plain_row(line, tab_size))+ .collect::<Vec<_>>()+ });+ if let Some(expected) = &expected {+ assert_eq!(+ text,+ expected+ .iter()+ .map(|row| row.text.as_str())+ .collect::<Vec<_>>()+ .join("\n"),+ "operation {operation}: independent expansion"+ );+ }+ let lines = text.split('\n').collect::<Vec<_>>();+ let raw_lines = raw.split('\n').collect::<Vec<_>>();+ let raw_boundaries = grapheme_boundaries(&raw);+ let mut query = ColumnarSelectionRows::new(snapshot);+ let mut rebuilt_query = ColumnarSelectionRows::new(rebuilt);+ assert_eq!(+ snapshot.tab_snapshot().max_point().row() as usize + 1,+ lines.len()+ );+ let sources = scalar_boundaries(&raw);+ for (start, end) in [+ (0, raw.len()),+ (+ sources[rng.random_range(0..sources.len())],+ sources[rng.random_range(0..sources.len())],+ ),+ ] {+ let point = |offset| {+ Point::new(+ raw[..offset].matches('\n').count() as u32,+ raw[..offset].rsplit('\n').next().expect("line").len() as u32,+ )+ };+ let range = point(start)..point(end);+ let columns = query.columns_for_range(range.clone());+ assert_eq!(+ columns,+ rebuilt_query.columns_for_range(range.clone()),+ "operation {operation}: source {range:?}"+ );+ if let Some(expected) = &expected {+ let column = |point: Point| {+ expected[point.row as usize]+ .columns+ .iter()+ .find(|(byte, _)| *byte == point.column)+ .expect("source byte")+ .1+ };+ let (start, end) = (column(range.start), column(range.end));+ assert_eq!(+ columns,+ start.min(end)..start.max(end),+ "operation {operation}: independent source {range:?}"+ );+ }+ }+ let folded = snapshot.fold_snapshot().text();+ let expanded = folded+ .split('\n')+ .map(|line| plain_row(line, tab_size))+ .collect::<Vec<_>>();+ let mut rows = vec![+ 0,+ lines.len() - 1,+ rng.random_range(0..lines.len()),+ rng.random_range(0..lines.len()),+ ];+ rows.sort_unstable();+ rows.dedup();+ for row in rows {+ assert_eq!(lines[row], expanded[row].text);+ let boundaries = &expanded[row].boundaries;+ let len = boundaries.len() as u32 - 1;+ assert_eq!(+ snapshot.tab_snapshot().line_len(row as u32),+ lines[row].len() as u32+ );+ assert_eq!(+ query.row(row as u32).columns_for_bytes(0..u32::MAX).end,+ len,+ "operation {operation}: row {row}"+ );+ assert_eq!(+ rebuilt_query+ .row(row as u32)+ .columns_for_bytes(0..u32::MAX)+ .end,+ len+ );+ let candidates = enumerated_points(snapshot, &raw, row as u32, boundaries);+ let middle = rng.random_range(0..=len + 1);+ let requests = [+ 0..0,+ 0..u32::MAX,+ middle..middle,+ middle..middle + 1,+ middle..rng.random_range(middle..=len + 1),+ len..len,+ len..len + 1,+ u32::MAX..u32::MAX,+ ]+ .map(|columns| (row as u32, columns));+ let answers = query.points_for_rows(&requests);+ let rebuilt_answers = rebuilt_query.points_for_rows(&requests);+ let mut checked_points = HashSet::default();+ for (((_, columns), points), rebuilt_points) in+ requests.into_iter().zip(answers).zip(rebuilt_answers)+ {+ if blocks_agree {+ assert_eq!(+ points, rebuilt_points,+ "operation {operation}: row {row}, columns {columns:?}"+ );+ }+ if let Some(expected) = &expected {+ assert_eq!(+ points,+ expected_points(row as u32, &columns, &expected[row]),+ "operation {operation}: independent row {row}, columns {columns:?}"+ );+ }+ let expected = nearest_points(&columns, len, &candidates);+ assert_eq!(+ points, expected,+ "operation {operation}: enumerated raw boundaries, row {row}, columns {columns:?}, raw {raw:?}, tab {text:?}"+ );+ if let Some((start, end)) = points {+ assert!(start <= end);+ for point in [start, end] {+ if !checked_points.insert(point) {+ continue;+ }+ let line = raw_lines+ .get(point.row as usize)+ .expect("raw row in bounds");+ assert!(point.column as usize <= line.len());+ let offset = raw_lines+ .iter()+ .take(point.row as usize)+ .map(|line| line.len() + 1)+ .sum::<usize>()+ + point.column as usize;+ assert_eq!(+ raw_boundaries+ .get(raw_boundaries.partition_point(|boundary| *boundary < offset))+ .copied(),+ Some(offset),+ "operation {operation}: full-buffer grapheme {point:?}, raw {raw:?}"+ );+ let forward = snapshot+ .tab_snapshot()+ .point_to_tab_point(point, Bias::Left);+ assert_eq!(forward.row(), row as u32);+ assert_eq!(+ snapshot+ .tab_snapshot()+ .tab_point_to_point(forward, Bias::Left),+ point+ );+ let column = boundaries+ .binary_search(&(forward.column() as usize))+ .expect("tab grapheme boundary")+ as u32;+ assert_eq!(+ query.points_for_row(row as u32, &(column..column)),+ Some((point, point))+ );+ let display = point.to_display_point(snapshot);+ assert!(!snapshot.is_block_line(display.row()));+ assert_eq!(display.to_point(snapshot), point);+ }+ }+ }+ }+ assert_eq!(query.points_for_row(lines.len() as u32, &(0..0)), None);+ }++ fn separated_columnar_ranges(+ row: u32,+ indices: Range<usize>,+ stride: u32,+ width: u32,+ reversed: bool,+ ) -> Vec<Range<Point>> {+ indices+ .map(|index| {+ let start = Point::new(row, index as u32 * stride);+ let end = Point::new(row, start.column + width);+ if reversed { end..start } else { start..end }+ })+ .collect()+ }++ fn set_columnar_action_state(+ cx: &mut EditorTestContext,+ text: &str,+ expected: &[Range<Point>],+ ) {+ cx.update_editor(|editor, window, cx| {+ editor.set_text(text, window, cx);+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.select_ranges(expected.iter().cloned());+ });+ assert_eq!(+ editor+ .selections+ .ranges::<Point>(&editor.display_snapshot(cx)),+ expected,+ );+ });+ }++ #[track_caller]+ fn assert_columnar_action_work(+ cx: &mut EditorTestContext,+ above: bool,+ expected: &[Range<Point>],+ work_bound: usize,+ ) {+ cx.update_editor(|editor, window, cx| {+ ROW_WORK.set((0, 0));+ if above {+ editor.add_selection_above(+ &AddSelectionAbove {+ skip_soft_wrap: true,+ },+ window,+ cx,+ );+ } else {+ editor.add_selection_below(+ &AddSelectionBelow {+ skip_soft_wrap: true,+ },+ window,+ cx,+ );+ }+ let (boundaries, chunks) = ROW_WORK.replace((0, 0));+ assert!(boundaries > 0);+ assert!(chunks > 0);+ assert!(+ boundaries + chunks <= work_bound,+ "above {above}: {boundaries} boundaries + {chunks} chunks > {work_bound}",+ );+ let actual = editor+ .selections+ .ranges::<Point>(&editor.display_snapshot(cx));+ assert_eq!(actual.len(), expected.len(), "above {above}");+ for (index, (actual, expected)) in actual.iter().zip(expected).enumerate() {+ assert_eq!(actual, expected, "above {above}, selection {index}");+ }+ });+ }+}diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rsindex b2ba2c5e4cc..f65dbf40524 100644--- a/crates/editor/src/display_map.rs+++ b/crates/editor/src/display_map.rs@@ -127,7 +127,7 @@ use std::{fmt::Debug,iter,num::NonZeroU32,- ops::{self, Add, Range, Sub},+ ops::{self, Add, Range, RangeInclusive, Sub},sync::Arc,};@@ -137,7 +137,8 @@ use crate::{use block_map::{BlockPointCursor, BlockRow, BlockSnapshot};use fold_map::{FoldPointCursor, FoldSnapshot};use inlay_map::{BufferOffsetToInlayPointCursor, InlaySnapshot};-use tab_map::{TabPoint, TabPointCursor, TabSnapshot};+pub(crate) use tab_map::TabPoint;+use tab_map::{TabPointCursor, TabSnapshot};use wrap_map::{WrapMap, WrapPatch, WrapPointCursor};#[derive(Copy, Clone, Debug, PartialEq, Eq)]@@ -1549,34 +1550,6 @@ impl DisplaySnapshot {&self.block_snapshot.wrap_snapshot.tab_snapshot}- /// The column `point` sits at once tabs are expanded, which is where it appears- /// on screen when the line isn't soft-wrapped. Unlike a display column this is- /// counted from the start of the buffer row rather than the wrapped segment.- pub(crate) fn tab_expanded_column(&self, point: Point) -> u32 {- self.tab_snapshot()- .point_to_tab_point(point, Bias::Left)- .0- .column- }-- /// Inverse of [`Self::tab_expanded_column`], clamped to the end of the row.- pub(crate) fn point_for_tab_expanded_column(- &self,- buffer_row: MultiBufferRow,- column: u32,- ) -> Point {- let tab_snapshot = self.tab_snapshot();- let tab_row = tab_snapshot.buffer_row_to_tab_row(buffer_row);- let column = column.min(tab_snapshot.line_len(tab_row));- tab_snapshot.tab_point_to_point(TabPoint(Point::new(tab_row, column)), Bias::Left)- }-- /// The length of `buffer_row` once tabs are expanded.- pub(crate) fn tab_expanded_line_len(&self, buffer_row: MultiBufferRow) -> u32 {- let tab_snapshot = self.tab_snapshot();- tab_snapshot.line_len(tab_snapshot.buffer_row_to_tab_row(buffer_row))- }-pub fn fold_snapshot(&self) -> &FoldSnapshot {&self.block_snapshot.wrap_snapshot.tab_snapshot.fold_snapshot}@@ -2500,6 +2473,31 @@ impl DisplaySnapshot {Bias::Right,)}++ pub(crate) fn fully_replaced_tab_rows(&self, row: u32) -> Option<RangeInclusive<u32>> {+ if !self.block_snapshot.has_replacement_blocks()+ || row > self.tab_snapshot().max_point().row()+ {+ return None;+ }+ let wraps = self.wrap_snapshot();+ let wrap_point = wraps.tab_point_to_wrap_point(TabPoint::new(row, 0));+ let input_range = self+ .block_snapshot+ .replacement_block_input_range(wrap_point.row())?;+ let start = wraps.to_tab_point(WrapPoint::new(input_range.start, 0));+ let start_row = start.row().checked_add(u32::from(start.column() > 0))?;+ let end_row = if input_range.end > wraps.max_point().row() {+ self.tab_snapshot().max_point().row()+ } else {+ wraps+ .to_tab_point(WrapPoint::new(input_range.end, 0))+ .row()+ .checked_sub(1)?+ };+ let rows = start_row..=end_row;+ rows.contains(&row).then_some(rows)+ }}fn diagnostic_style(severity: lsp::DiagnosticSeverity, colors: &StatusColors) -> Hsla {diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rsindex 4306d239e3c..f0a164abaec 100644--- a/crates/editor/src/display_map/block_map.rs+++ b/crates/editor/src/display_map/block_map.rs@@ -2628,6 +2628,11 @@ impl BlockSnapshot {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<'_> {@@ -2951,8 +2956,8 @@ mod tests {use super::*;use crate::{display_map::{- Companion, fold_map::FoldMap, fold_map::FoldPlaceholder, inlay_map::InlayMap,- tab_map::TabMap, wrap_map::WrapMap,+ Companion, DisplayMap, fold_map::FoldMap, fold_map::FoldPlaceholder,+ inlay_map::InlayMap, tab_map::TabMap, wrap_map::WrapMap,},test::test_font,};@@ -2961,6 +2966,7 @@ mod tests {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;@@ -5618,6 +5624,91 @@ mod tests {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);diff --git a/crates/editor/src/display_map/fold_map.rs b/crates/editor/src/display_map/fold_map.rsindex 2739a857aef..cfa9781983e 100644--- a/crates/editor/src/display_map/fold_map.rs+++ b/crates/editor/src/display_map/fold_map.rs@@ -926,6 +926,14 @@ impl FoldSnapshot {}}+ pub(crate) fn placeholder_range_at(&self, point: FoldPoint) -> Option<Range<FoldPoint>> {+ let (start, end, item) = self+ .transforms+ .find::<FoldPoint, _>((), &point, Bias::Right);+ item.filter(|transform| transform.placeholder.is_some())+ .map(|_| start..end)+ }+#[ztracing::instrument(skip_all)]pub(crate) fn chunks<'a>(&'a self,diff --git a/crates/editor/src/display_map/tab_map.rs b/crates/editor/src/display_map/tab_map.rsindex 611be1518b4..ef087833399 100644--- a/crates/editor/src/display_map/tab_map.rs+++ b/crates/editor/src/display_map/tab_map.rs@@ -321,7 +321,7 @@ impl TabSnapshot {chunk: Chunk {text: unsafe { std::str::from_utf8_unchecked(&SPACES[..to_next_stop as usize]) },is_tab: true,- chars: 1u128.unbounded_shl(to_next_stop) - 1,+ chars: u128::MAX.unbounded_shr(u128::BITS - to_next_stop),..Default::default()},inside_leading_tab: to_next_stop > 0,@@ -643,7 +643,7 @@ impl TabChunks<'_> {self.chunk = Chunk {text: unsafe { std::str::from_utf8_unchecked(&SPACES[..to_next_stop as usize]) },is_tab: true,- chars: 1u128.unbounded_shl(to_next_stop) - 1,+ chars: u128::MAX.unbounded_shr(u128::BITS - to_next_stop),..Default::default()};self.inside_leading_tab = to_next_stop > 0;@@ -692,7 +692,7 @@ impl<'a> Iterator for TabChunks<'a> {return Some(Chunk {text: unsafe { std::str::from_utf8_unchecked(&SPACES[..len as usize]) },is_tab: true,- chars: 1u128.unbounded_shl(len) - 1,+ chars: u128::MAX.unbounded_shr(u128::BITS - len),tabs: 0,newlines: 0,..self.chunk.clone()@@ -1299,6 +1299,75 @@ mod tests {}}+ #[gpui::test]+ fn test_max_tab_size_full_chunks(cx: &mut gpui::App) {+ for tab_size in [127, 128, 129] {+ let buffer = MultiBuffer::build_simple("\tα\t🏀", cx);+ let buffer_snapshot = buffer.read(cx).snapshot(cx);+ let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);+ let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);+ let (_, tab_snapshot) = TabMap::new(fold_snapshot, NonZeroU32::new(tab_size).unwrap());+ let width = tab_size.min(128);+ let expected = format!(+ "{}α{}🏀",+ " ".repeat(width as usize),+ " ".repeat(width as usize - 1)+ );+ let mut chunks = tab_snapshot.chunks(+ TabPoint::zero()..tab_snapshot.max_point(),+ LanguageAwareStyling {+ tree_sitter: false,+ diagnostics: false,+ },+ Highlights::default(),+ );+ assert_max_tab_chunk_bitmaps(&mut chunks, &expected);+ assert_eq!(tab_snapshot.text(), expected);+ assert_eq!(+ tab_snapshot.point_to_tab_point(Point::new(0, 4), Bias::Left),+ TabPoint::new(0, 2 * width + 1),+ );+ assert_eq!(+ tab_snapshot.tab_point_to_point(TabPoint::new(0, 2 * width + 1), Bias::Left),+ Point::new(0, 4),+ );+ }+ }++ #[gpui::test]+ fn test_max_tab_size_partial_chunks_and_seek(cx: &mut gpui::App) {+ let buffer = MultiBuffer::build_simple("\t🏀", cx);+ let buffer_snapshot = buffer.read(cx).snapshot(cx);+ let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);+ let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);+ let (_, tab_snapshot) = TabMap::new(fold_snapshot, NonZeroU32::new(128).unwrap());+ let expected = format!("{}🏀", " ".repeat(128));+ let mut reused = tab_snapshot.chunks(+ TabPoint::zero()..tab_snapshot.max_point(),+ LanguageAwareStyling {+ tree_sitter: false,+ diagnostics: false,+ },+ Highlights::default(),+ );+ for start in 0..=128 {+ for end in [start, (start + 1).min(128), 128, 132] {+ let range = TabPoint::new(0, start)..TabPoint::new(0, end);+ let mut chunks = tab_snapshot.chunks(+ range.clone(),+ LanguageAwareStyling {+ tree_sitter: false,+ diagnostics: false,+ },+ Highlights::default(),+ );+ assert_max_tab_chunk_bitmaps(&mut chunks, &expected[start as usize..end as usize]);+ reused.seek(range);+ assert_max_tab_chunk_bitmaps(&mut reused, &expected[start as usize..end as usize]);+ }+ }+ }+#[gpui::test]fn test_empty_chunk_after_leading_tab_trim(cx: &mut gpui::App) {// We fold "hello" (offsets 1..6) so the fold map creates a@@ -1755,4 +1824,26 @@ mod tests {}}}++ fn assert_max_tab_chunk_bitmaps(chunks: &mut TabChunks<'_>, expected_text: &str) {+ let initial_mask = chunks+ .chunk+ .text+ .char_indices()+ .fold(0u128, |mask, (index, _)| mask | (1u128 << index));+ assert_eq!(chunks.chunk.chars, initial_mask);+ let text = chunks+ .map(|chunk| {+ let expected_mask = chunk+ .text+ .char_indices()+ .fold(0u128, |mask, (index, _)| mask | (1u128 << index));+ assert_eq!(chunk.chars, expected_mask, "chunk {:?}", chunk.text);+ assert_eq!(chunk.tabs, 0);+ assert_eq!(chunk.newlines, 0);+ chunk.text+ })+ .collect::<String>();+ assert_eq!(text, expected_text);+ }}diff --git a/crates/editor/src/edit_prediction.rs b/crates/editor/src/edit_prediction.rsindex 1d2f5d6109c..b3172ce32ed 100644--- a/crates/editor/src/edit_prediction.rs+++ b/crates/editor/src/edit_prediction.rs@@ -485,8 +485,11 @@ impl Editor {self.buffer.read(cx).last_transaction_id(cx){if transaction_id_prev != Some(transaction_id_now) {- self.selection_history- .insert_transaction(transaction_id_now, selections);+ self.selection_history.insert_transaction(+ transaction_id_now,+ selections,+ self.add_selections_state.clone(),+ );}}diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rsindex bb9820f9fc1..2ad7d780c04 100644--- a/crates/editor/src/editor.rs+++ b/crates/editor/src/editor.rs@@ -63,6 +63,7 @@ pub mod test;mod clipboard;mod code_actions;+mod columnar_selection;mod completions;mod config;mod cursor_animation;@@ -1436,6 +1437,8 @@ struct DeferredSelectionEffectsState {pub struct TransactionSelections {pub undo: Arc<[Selection<Anchor>]>,pub redo: Option<Arc<[Selection<Anchor>]>>,+ undo_add_selections_state: Option<AddSelectionsState>,+ redo_add_selections_state: Option<AddSelectionsState>,}#[derive(Default)]@@ -1452,6 +1455,7 @@ impl SelectionHistory {&mut self,transaction_id: TransactionId,selections: Arc<[Selection<Anchor>]>,+ add_selections_state: Option<AddSelectionsState>,) {if selections.is_empty() {log::error!(@@ -1465,6 +1469,8 @@ impl SelectionHistory {TransactionSelections {undo: selections,redo: None,+ undo_add_selections_state: add_selections_state,+ redo_add_selections_state: None,},);}@@ -1547,12 +1553,14 @@ struct RowHighlight {#[derive(Clone, Debug)]struct AddSelectionsState {groups: Vec<AddSelectionsGroup>,+ skip_soft_wrap: bool,}#[derive(Clone, Debug)]struct AddSelectionsGroup {above: bool,stack: Vec<usize>,+ goal_source: Option<Range<Anchor>>,}#[derive(Clone)]@@ -3530,9 +3538,14 @@ impl Editor {return;}+ let cancelling_group = self.selections.pending_anchor().is_none()+ && self.selections.disjoint_anchors().len() > 1;if self.mode.is_full()&& self.change_selections(Default::default(), window, cx, |s| s.try_cancel()){+ if cancelling_group {+ self.add_selections_state = None;+ }cx.notify();return;}@@ -7913,13 +7926,23 @@ impl Editor {fn restore_selections(&mut self,- selections: Option<Arc<[Selection<Anchor>]>>,+ selections: Option<(Arc<[Selection<Anchor>]>, Option<AddSelectionsState>)>,window: &mut Window,cx: &mut Context<Self>,) {- if let Some(selections) = selections.filter(|selections| !selections.is_empty()) {- self.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {- s.select_anchors(selections.to_vec());+ if let Some((selections, add_selections_state)) =+ selections.filter(|(selections, _)| !selections.is_empty())+ {+ self.with_selection_effects_deferred(window, cx, |editor, window, cx| {+ editor.change_selections(+ SelectionEffects::no_scroll(),+ window,+ cx,+ |selection_collection| {+ selection_collection.select_anchors_unexpanded(selections.to_vec());+ },+ );+ editor.add_selections_state = add_selections_state;});}}@@ -7934,7 +7957,12 @@ impl Editor {if transaction.is_none() {log::error!("No selection history for undone transaction; selection unchanged");}- let selections = transaction.map(|transaction| transaction.undo.clone());+ let selections = transaction.map(|transaction| {+ (+ transaction.undo.clone(),+ transaction.undo_add_selections_state.clone(),+ )+ });self.restore_selections(selections, window, cx);self.request_autoscroll(Autoscroll::fit(), cx);self.unmark_text(window, cx);@@ -7956,10 +7984,14 @@ impl Editor {}if let Some(transaction_id) = self.buffer.update(cx, |buffer, cx| buffer.redo(cx)) {- let selections = self- .selection_history- .transaction(transaction_id)- .and_then(|transaction| transaction.redo.clone());+ let selections =+ self.selection_history+ .transaction(transaction_id)+ .and_then(|transaction| {+ transaction.redo.clone().map(|selections| {+ (selections, transaction.redo_add_selections_state.clone())+ })+ });self.restore_selections(selections, window, cx);self.request_autoscroll(Autoscroll::fit(), cx);self.unmark_text(window, cx);@@ -8486,7 +8518,7 @@ impl Editor {buffers.retain(|buffer| !buffer.read(cx).read_only());let transaction_id_prev = buffer.read(cx).last_transaction_id(cx);- let selections_prev = transaction_id_prev+ let (selections_prev, add_selections_state_prev) = transaction_id_prev.and_then(|transaction_id_prev| {// default to selections as they were after the last edit, if we have them,// instead of how they are now.@@ -8494,9 +8526,19 @@ impl Editor {// will take you back to where you made the last edit, instead of staying where you scrolledself.selection_history.transaction(transaction_id_prev)- .map(|t| t.undo.clone())+ .map(|transaction| {+ (+ transaction.undo.clone(),+ transaction.undo_add_selections_state.clone(),+ )+ })})- .unwrap_or_else(|| self.selections.disjoint_anchors_arc());+ .unwrap_or_else(|| {+ (+ self.selections.disjoint_anchors_arc(),+ self.add_selections_state.clone(),+ )+ });let mut timeout = cx.background_executor().timer(FORMAT_TIMEOUT).fuse();let format = project.update(cx, |project, cx| {@@ -8528,9 +8570,11 @@ impl Editor {if has_new_transaction {editor.update(cx, |editor, _| {- editor- .selection_history- .insert_transaction(transaction_id_now, selections_prev);+ editor.selection_history.insert_transaction(+ transaction_id_now,+ selections_prev,+ add_selections_state_prev,+ );}).ok();}@@ -8700,8 +8744,11 @@ impl Editor {.buffer.update(cx, |buffer, cx| buffer.start_transaction_at(now, cx)){- self.selection_history- .insert_transaction(tx_id, self.selections.disjoint_anchors_arc());+ self.selection_history.insert_transaction(+ tx_id,+ self.selections.disjoint_anchors_arc(),+ self.add_selections_state.clone(),+ );cx.emit(EditorEvent::TransactionBegun {transaction_id: tx_id,});@@ -8722,6 +8769,7 @@ impl Editor {{if let Some(transaction) = self.selection_history.transaction_mut(transaction_id) {transaction.redo = Some(self.selections.disjoint_anchors_arc());+ transaction.redo_add_selections_state = self.add_selections_state.clone();} else {log::error!("unexpectedly ended a transaction that wasn't started by this editor");}@@ -8740,7 +8788,17 @@ impl Editor {) -> bool {self.selection_history.transaction_mut(transaction_id)- .map(modify)+ .map(|transaction| {+ let undo = transaction.undo.clone();+ let redo = transaction.redo.clone();+ modify(transaction);+ if undo != transaction.undo {+ transaction.undo_add_selections_state = None;+ }+ if redo != transaction.redo {+ transaction.redo_add_selections_state = None;+ }+ }).is_some()}diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rsindex f57cc2450d6..e92b1b89496 100644--- a/crates/editor/src/editor_tests.rs+++ b/crates/editor/src/editor_tests.rs@@ -11859,6 +11859,1983 @@ async fn test_split_selection_into_lines_interacting_with_creases(cx: &mut TestA);}+#[gpui::test]+async fn test_add_selection_grapheme_columns(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (text, columns) in [+ ("e\u{301}x|Z\néé|Zˇ", [4..4, 4..4]),+ ("e\u{301}x|Z\néé|Zˇ", [4..5, 4..5]),+ ("éx|Z\ne\u{301}x|Zˇ", [3..3, 4..4]),+ ("👩\u{200d}💻x|Z\nax|Zˇ", [12..13, 2..3]),+ ("🇦🇶x|Z\nax|Zˇ", [8..9, 1..2]),+ ("\t\u{301}x\n\t\u{301}xˇ", [1..1, 1..1]),+ ("\t\u{301}x\n\t\u{301}xˇ", [1..3, 1..3]),+ ] {+ for above in [false, true] {+ for reversed in [false, true] {+ cx.set_state(text);+ cx.update_editor(|editor, window, cx| {+ assert_add_selection_pair(editor, columns.clone(), above, reversed, window, cx);+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_goal_after_moving(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ cx.set_state("abˇcdef\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ editor.move_right(&MoveRight, window, cx);+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("abcˇdef\nabcˇdef\nabcˇdef");+}++#[gpui::test]+async fn test_add_selection_unwrapped_unprojectable_sources(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for above in [false, true] {+ for reversed in [false, true] {+ for mixed in [false, true] {+ cx.set_state("aˇ\nb\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ let position = editor+ .buffer+ .read(cx)+ .snapshot(cx)+ .anchor_before(Point::new(1, 0));+ editor.splice_inlays(+ &[],+ vec![inlays::Inlay::mock_hint(0, position, "HH")],+ cx,+ );+ let source = if reversed {+ Point::new(1, 0)..Point::new(0, 1)+ } else {+ Point::new(0, 1)..Point::new(1, 0)+ };+ let other_row = if above { 3 } else { 2 };+ let mut original = vec![source.clone()];+ if mixed {+ original.push(Point::new(other_row, 1)..Point::new(other_row, 1));+ }+ editor.change_selections(+ SelectionEffects::no_scroll(),+ window,+ cx,+ |selections| selections.select_ranges(original.clone()),+ );+ let original_id = editor.selections.first_anchor().id;+ add_selection_in_direction(editor, above, true, window, cx);+ let mut expected = vec![source];+ if mixed {+ expected.extend([+ Point::new(2, 1)..Point::new(2, 1),+ Point::new(3, 1)..Point::new(3, 1),+ ]);+ }+ assert_add_selection_ranges(editor, &expected, cx);+ assert_eq!(editor.selections.first_anchor().id, original_id);+ add_selection_in_direction(editor, !above, true, window, cx);+ assert_add_selection_ranges(editor, &original, cx);+ assert_eq!(editor.selections.first_anchor().id, original_id);+ editor.splice_inlays(&[project::InlayId::Hint(0)], Vec::new(), cx);+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_multiline_goal_and_reversal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (above, text, source, columns) in [+ (+ false,+ "abc\ndefghi\nuvwxyz\nabcdefˇ",+ Point::new(0, 1)..Point::new(1, 4),+ [1..3, 1..4, 1..4, 1..4],+ ),+ (+ true,+ "abcdef\nuvwxyz\ndefghi\nabcˇ",+ Point::new(2, 4)..Point::new(3, 1),+ [1..4, 1..4, 1..4, 1..3],+ ),+ ] {+ for reversed in [false, true] {+ for deferred in [false, true] {+ cx.set_state(text);+ cx.update_editor(|editor, window, cx| {+ editor.change_selections(+ SelectionEffects::no_scroll(),+ window,+ cx,+ |selections| {+ selections.select_ranges([if reversed {+ source.end..source.start+ } else {+ source.clone()+ }]);+ },+ );+ for (direction, count) in [+ (above, 3),+ (above, 4),+ (!above, 3),+ (above, 4),+ (!above, 3),+ (!above, 2),+ (!above, 1),+ (!above, 1),+ (above, 2),+ ] {+ if deferred {+ editor.with_selection_effects_deferred(+ window,+ cx,+ |editor, window, cx| {+ add_selection_in_direction(editor, direction, true, window, cx);+ },+ );+ } else {+ add_selection_in_direction(editor, direction, true, window, cx);+ }+ let expected = columns+ .iter()+ .enumerate()+ .filter(|(row, _)| {+ if above {+ *row >= 4 - count+ } else {+ *row < count+ }+ })+ .map(|(row, columns)| {+ let start = Point::new(row as u32, columns.start);+ let end = Point::new(row as u32, columns.end);+ if reversed { end..start } else { start..end }+ })+ .collect::<Vec<_>>();+ assert_add_selection_ranges(editor, &expected, cx);+ }+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_single_projection_retains_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ cx.set_state("a«bc\nˇ»\nabcdef");+ cx.update_editor(|editor, window, cx| {+ let position = editor+ .buffer+ .read(cx)+ .snapshot(cx)+ .anchor_before(Point::new(1, 0));+ editor.splice_inlays(&[], vec![inlays::Inlay::mock_hint(0, position, "HHHH")], cx);+ editor.with_selection_effects_deferred(window, cx, |editor, window, cx| {+ add_selection_in_direction(editor, true, true, window, cx);+ });+ });+ cx.assert_editor_state("a«bcˇ»\n\nabcdef");+ for _ in 0..2 {+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("a«bcˇ»\n\na«bcdˇ»ef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, true, true, window, cx);+ });+ cx.assert_editor_state("a«bcˇ»\n\nabcdef");+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_multiline_goal_after_moving_or_typing(+ cx: &mut TestAppContext,+) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for typing in [false, true] {+ cx.set_state("a«bc\ndefgˇ»hi\nuvwxyz\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ if typing {+ editor.handle_input("X", window, cx);+ } else {+ editor.move_right(&MoveRight, window, cx);+ }+ add_selection_in_direction(editor, false, true, window, cx);+ });+ let expected = if typing {+ "aXˇ\ndXˇhi\nuXˇyz\nabˇcdef"+ } else {+ "abcˇ\ndefgˇhi\nuvwxˇyz\nabcˇdef"+ };+ cx.assert_editor_state(expected);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, true, true, window, cx);+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state(expected);+ }+}++#[gpui::test]+fn test_add_selection_unwrapped_reseeds_after_folding_source_buffer(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new_multibuffer(cx, ["«abcdef»", "«x\nabcdef\nabcdef»"]);+ let source_buffer_id = cx.multibuffer(|buffer, cx| {+ buffer+ .snapshot(cx)+ .excerpts()+ .next()+ .expect("source excerpt")+ .context+ .start+ .buffer_id+ });+ cx.set_selections_state("abcdˇef\nx\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nxˇ\nabcdˇef\nabcdef");+ cx.update_editor(|editor, _, cx| {+ editor.fold_buffer(source_buffer_id, cx);+ });+ cx.assert_editor_state("abcdef\nxˇ\nabcdˇef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("abcdef\nxˇ\nabcdˇef\naˇbcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, true, true, window, cx);+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("abcdef\nxˇ\nabcdˇef\naˇbcdef");+}++#[gpui::test]+fn test_add_selection_unwrapped_retains_goal_after_folding_projection_buffer(+ cx: &mut TestAppContext,+) {+ init_test(cx, |_| {});+ for above in [false, true] {+ let mut cx = EditorTestContext::new_multibuffer(+ cx,+ if above {+ ["«abcdef»", "«uvwxyz»", "«defghi\nabc»"]+ } else {+ ["«abc\ndefghi»", "«uvwxyz»", "«abcdef»"]+ },+ );+ let projection_buffer_id = cx.multibuffer(|buffer, cx| {+ buffer+ .snapshot(cx)+ .excerpts()+ .nth(1)+ .expect("projection excerpt")+ .context+ .start+ .buffer_id+ });+ cx.set_selections_state(if above {+ "abcdef\nuvwxyz\ndefg«hi\naˇ»bc"+ } else {+ "a«bc\ndefgˇ»hi\nuvwxyz\nabcdef"+ });+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, true, window, cx);+ });+ cx.assert_editor_state(if above {+ "abcdef\nu«vwxˇ»yz\nd«efgˇ»hi\na«bcˇ»"+ } else {+ "a«bcˇ»\nd«efgˇ»hi\nu«vwxˇ»yz\nabcdef"+ });+ cx.update_editor(|editor, _, cx| {+ editor.fold_buffer(projection_buffer_id, cx);+ });+ cx.assert_editor_state(if above {+ "abcdef\nuvwxyz\nd«efgˇ»hi\na«bcˇ»"+ } else {+ "a«bcˇ»\nd«efgˇ»hi\nuvwxyz\nabcdef"+ });+ for _ in 0..2 {+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, true, window, cx);+ });+ cx.assert_editor_state(if above {+ "a«bcdˇ»ef\nuvwxyz\nd«efgˇ»hi\na«bcˇ»"+ } else {+ "a«bcˇ»\nd«efgˇ»hi\nuvwxyz\na«bcdˇ»ef"+ });+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, !above, true, window, cx);+ });+ }+ }+}++#[gpui::test]+async fn test_add_selection_reverses_groups_with_deleted_sources(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ cx.set_state("abˇcdef\nabcdef\nabcdef\nabˇcdef\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state("abˇcdef\nabˇcdef\nabcdef\nabˇcdef\nabˇcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ let snapshot = editor.display_snapshot(cx);+ let source_ids = editor+ .selections+ .all::<Point>(&snapshot)+ .into_iter()+ .filter(|selection| selection.start.row % 3 == 0)+ .map(|selection| selection.id)+ .collect::<Vec<_>>();+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ for id in source_ids {+ selections.delete(id);+ }+ });+ add_selection_in_direction(editor, true, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state("abˇcdef\nabˇcdef\nabcdef\nabˇcdef\nabˇcdef\nabcdef");+ }+}++#[gpui::test]+async fn test_add_selection_after_members_span_rows(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ cx.set_state("abˇcdef\nabcdef\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ editor.select_down(&SelectDown, window, cx);+ });+ cx.assert_editor_state("ab«cdef\nabˇ»«cdef\nabˇ»cdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state("ab«cdef\nabˇ»«cdef\nabˇ»cdef\nabˇcdef");+ }+}++#[gpui::test]+async fn test_add_selection_fresh_pixel_source_reseeds_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for above in [false, true] {+ cx.set_state(if above {+ "abcdef\nx\nabcdˇef"+ } else {+ "abcdˇef\nx\nabcdef"+ });+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, false, window, cx);+ });+ cx.assert_editor_state(if above {+ "abcdef\nxˇ\nabcdˇef"+ } else {+ "abcdˇef\nxˇ\nabcdef"+ });+ cx.update_editor(|editor, window, cx| {+ let source_row = if above { 2 } else { 0 };+ let source_id = editor+ .selections+ .disjoint_anchors()+ .iter()+ .find(|selection| {+ selection+ .start+ .to_point(&editor.buffer.read(cx).snapshot(cx))+ .row+ == source_row+ })+ .expect("source selection")+ .id;+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.delete(source_id);+ });+ let clamped_id = editor.selections.disjoint_anchors()[0].id;+ add_selection_in_direction(editor, above, false, window, cx);+ assert_eq!(+ stored_selection_ranges(editor, cx),+ if above {+ [+ Point::new(0, 1)..Point::new(0, 1),+ Point::new(1, 1)..Point::new(1, 1),+ ]+ } else {+ [+ Point::new(1, 1)..Point::new(1, 1),+ Point::new(2, 1)..Point::new(2, 1),+ ]+ }+ );+ assert!(+ editor+ .selections+ .disjoint_anchors()+ .iter()+ .any(|selection| selection.id == clamped_id)+ );+ });+ }+}++#[gpui::test]+async fn test_add_selection_keeps_fresh_source_inside_fold(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ cx.set_state("abˇcdef\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ editor.fold_creases(+ vec![Crease::simple(+ Point::new(0, 0)..Point::new(1, 6),+ FoldPlaceholder::test(),+ )],+ false,+ window,+ cx,+ );+ assert_eq!(editor.display_text(cx), "⋯\nabcdef");+ let source_id = editor.selections.disjoint_anchors()[0].id;+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ let stored = stored_selection_ranges(editor, cx);+ assert_eq!(stored[0], Point::new(0, 2)..Point::new(0, 2));+ assert_eq!(stored.len(), 2);+ assert_eq!(stored[1].start.row, 2);+ assert_eq!(editor.selections.disjoint_anchors()[0].id, source_id);+ add_selection_in_direction(editor, true, skip_soft_wrap, window, cx);+ assert_eq!(+ stored_selection_ranges(editor, cx),+ [Point::new(0, 2)..Point::new(0, 2)]+ );+ assert_eq!(editor.selections.disjoint_anchors()[0].id, source_id);+ });+ }+}++#[gpui::test]+async fn test_add_selection_keeps_group_members_coalesced_by_fold(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ cx.set_state("abˇcdef\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ editor.fold_creases(+ vec![Crease::simple(+ Point::new(0, 0)..Point::new(1, 6),+ FoldPlaceholder::test(),+ )],+ false,+ window,+ cx,+ );+ assert_eq!(editor.display_text(cx), "⋯\nabcdef");+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ let stored = stored_selection_ranges(editor, cx);+ assert_eq!(+ stored[..2],+ [+ Point::new(0, 2)..Point::new(0, 2),+ Point::new(1, 2)..Point::new(1, 2),+ ]+ );+ assert_eq!(stored.len(), 3);+ assert_eq!(stored[2].start.row, 2);+ add_selection_in_direction(editor, true, skip_soft_wrap, window, cx);+ add_selection_in_direction(editor, true, skip_soft_wrap, window, cx);+ assert_eq!(+ stored_selection_ranges(editor, cx),+ [Point::new(0, 2)..Point::new(0, 2)]+ );+ });+ }+}++#[gpui::test]+fn test_add_selection_keeps_sources_on_block_rows(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ for skip_soft_wrap in [false, true] {+ for visible_source in [None, Some(false), Some(true)] {+ let mut cx = EditorTestContext::new_multibuffer(cx, ["«abcdef»", "«abcdef\nabcdef»"]);+ let buffer_ids = cx.multibuffer(|buffer, cx| {+ buffer+ .snapshot(cx)+ .excerpts()+ .map(|excerpt| excerpt.context.start.buffer_id)+ .collect::<Vec<_>>()+ });+ let folded = if visible_source.is_some() {+ &buffer_ids[..1]+ } else {+ &buffer_ids[..]+ };+ cx.set_selections_state("abˇcdef\nabcdef\nabcdef");+ cx.update_editor(|editor, _, cx| {+ editor.fold_buffers(folded.iter().copied(), cx);+ });+ let mut expected = vec![Point::zero()..Point::zero()];+ cx.update_editor(|editor, window, cx| {+ assert_eq!(stored_selection_ranges(editor, cx), expected);+ if let Some(pending) = visible_source {+ expected.push(Point::new(1, 2)..Point::new(1, 2));+ if pending {+ let position =+ Point::new(1, 2).to_display_point(&editor.display_snapshot(cx));+ editor.begin_selection(position, true, 1, window, cx);+ assert!(editor.selections.pending_anchor().is_some());+ } else {+ editor.change_selections(+ SelectionEffects::no_scroll(),+ window,+ cx,+ |selections| {+ selections.select_ranges(expected.clone());+ },+ );+ }+ assert_eq!(stored_selection_ranges(editor, cx), expected);+ }+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ if visible_source.is_some() {+ expected.push(Point::new(2, 2)..Point::new(2, 2));+ }+ assert_eq!(stored_selection_ranges(editor, cx), expected);+ add_selection_in_direction(editor, true, skip_soft_wrap, window, cx);+ if visible_source.is_some() {+ expected.pop();+ }+ assert_eq!(stored_selection_ranges(editor, cx), expected);+ editor.handle_input("X", window, cx);+ });+ cx.update_editor(|editor, _, cx| {+ for buffer_id in folded {+ editor.unfold_buffer(*buffer_id, cx);+ }+ });+ cx.assert_editor_state(if visible_source.is_some() {+ "Xˇabcdef\nabXˇcdef\nabcdef"+ } else {+ "Xˇabcdef\nabcdef\nabcdef"+ });+ }+ }+}++#[gpui::test]+fn test_add_selection_skips_block_rows(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new_multibuffer(+ cx,+ ["«abcdef»", "«abcdefghij\nx»", "«abcdef»", "«abcdefghij\nx»"],+ );+ let folded_buffer_ids = cx.multibuffer(|buffer, cx| {+ buffer+ .snapshot(cx)+ .excerpts()+ .map(|excerpt| excerpt.context.start.buffer_id)+ .skip(1)+ .step_by(2)+ .collect::<Vec<_>>()+ });+ for skip_soft_wrap in [false, true] {+ for column in [0, 4] {+ let source = Point::new(0, column)..Point::new(0, column);+ cx.update_editor(|editor, window, cx| {+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.select_ranges([source.clone()]);+ });+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ assert_add_selection_ranges(+ editor,+ &[source.clone(), Point::new(1, column)..Point::new(1, column)],+ cx,+ );+ });+ }+ }+ cx.update_editor(|editor, _, cx| {+ editor.fold_buffers(folded_buffer_ids, cx);+ });+ for skip_soft_wrap in [false, true] {+ for (column, above) in [(0, false), (4, false), (0, true), (4, true)] {+ let source_row = if above { 3 } else { 0 };+ let source = Point::new(source_row, column)..Point::new(source_row, column);+ let target = Point::new(3 - source_row, column)..Point::new(3 - source_row, column);+ cx.update_editor(|editor, window, cx| {+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.select_ranges([source.clone()]);+ });+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ let mut expected = vec![source.clone(), target];+ expected.sort_by_key(|range| range.start);+ assert_add_selection_ranges(editor, &expected, cx);+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ assert_add_selection_ranges(editor, &expected, cx);+ add_selection_in_direction(editor, !above, skip_soft_wrap, window, cx);+ assert_add_selection_ranges(editor, std::slice::from_ref(&source), cx);+ });+ }+ }+}++#[gpui::test]+async fn test_add_selection_history_restores_groups(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (above, initial, two, three) in [+ (+ false,+ "abcdˇef\nab\nabcdef\nabcdef",+ "abcdˇef\nabˇ\nabcdef\nabcdef",+ "abcdˇef\nabˇ\nabcdˇef\nabcdef",+ ),+ (+ true,+ "abcdef\nabcdef\nab\nabcdˇef",+ "abcdef\nabcdef\nabˇ\nabcdˇef",+ "abcdef\nabcdˇef\nabˇ\nabcdˇef",+ ),+ ] {+ for skip_soft_wrap in [false, true] {+ for deferred in [false, true] {+ cx.set_state(initial);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state(two);+ cx.update_editor(|editor, window, cx| {+ if deferred {+ editor.with_selection_effects_deferred(window, cx, |editor, window, cx| {+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ });+ } else {+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ }+ });+ cx.assert_editor_state(three);+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ });+ cx.assert_editor_state(two);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state(three);+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ add_selection_in_direction(editor, !above, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state(initial);+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ });+ cx.assert_editor_state(two);+ cx.update_editor(|editor, window, cx| {+ editor.redo_selection(&RedoSelection, window, cx);+ });+ cx.assert_editor_state(initial);+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state(three);+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_history_deferred_batch(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ cx.set_state("abcdˇef\nab\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ editor.with_selection_effects_deferred(window, cx, |editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ });+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabcdˇef\nabcdˇef");+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ editor.redo_selection(&RedoSelection, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabcdˇef\nabcdˇef");+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabcdˇef\nabcdef");+ }+}++#[gpui::test]+async fn test_add_selection_history_deferred_external_movement(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for move_first in [false, true] {+ cx.set_state("abcdˇef\nab\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ if move_first {+ add_selection_in_direction(editor, false, true, window, cx);+ }+ editor.with_selection_effects_deferred(window, cx, |editor, window, cx| {+ if !move_first {+ add_selection_in_direction(editor, false, true, window, cx);+ }+ editor.move_right(&MoveRight, window, cx);+ if move_first {+ add_selection_in_direction(editor, false, true, window, cx);+ }+ });+ });+ if move_first {+ cx.assert_editor_state("abcdeˇf\nab\nˇabcdef\nabcdeˇf");+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabcdˇef\nabcdef");+ } else {+ cx.assert_editor_state("abcdeˇf\nab\nˇabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("abcdeˇf\nab\nˇabcdef\nabcdeˇf");+ }+ }+}++#[gpui::test]+async fn test_add_selection_history_restores_mode_before_switch(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ for deferred in [false, true] {+ cx.set_state("abcdˇef\nab\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ if deferred {+ editor.with_selection_effects_deferred(window, cx, |editor, window, cx| {+ add_selection_in_direction(editor, false, !skip_soft_wrap, window, cx);+ });+ } else {+ add_selection_in_direction(editor, false, !skip_soft_wrap, window, cx);+ }+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabˇcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ editor.redo_selection(&RedoSelection, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabˇcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state("abcdˇef\nabˇ\nabcdˇef\nabcdef");+ }+ }+}++#[gpui::test]+async fn test_add_selection_history_restores_unclipped_multiline_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (above, initial, three, four) in multiline_add_selection_history_states() {+ cx.set_state(initial);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, true, window, cx);+ add_selection_in_direction(editor, above, true, window, cx);+ });+ cx.assert_editor_state(four);+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ });+ cx.assert_editor_state(three);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, true, window, cx);+ });+ cx.assert_editor_state(four);+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ editor.redo_selection(&RedoSelection, window, cx);+ });+ cx.assert_editor_state(four);+ }+}++#[gpui::test]+async fn test_add_selection_text_undo_restores_multiline_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (above, initial, three, four) in multiline_add_selection_history_states() {+ for grouped in [false, true] {+ cx.set_state(initial);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, true, window, cx);+ editor.transact(window, cx, |editor, window, cx| {+ editor.insert("X", window, cx);+ if grouped {+ editor.insert("Y", window, cx);+ }+ });+ editor.undo(&Undo, window, cx);+ });+ cx.assert_editor_state(three);+ cx.update_editor(|editor, window, cx| {+ editor.redo(&Redo, window, cx);+ editor.undo(&Undo, window, cx);+ add_selection_in_direction(editor, above, true, window, cx);+ });+ cx.assert_editor_state(four);+ }+ }+}++#[gpui::test]+async fn test_add_selection_history_preserves_hidden_sources(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ for source_count in [1, 2] {+ cx.set_state("abˇcdef\nabcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ let sources = (0..source_count)+ .map(|row| Point::new(row, 2)..Point::new(row, 2))+ .collect::<Vec<_>>();+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.select_ranges(sources.clone());+ });+ editor.fold_creases(+ vec![Crease::simple(+ Point::new(0, 0)..Point::new(1, 6),+ FoldPlaceholder::test(),+ )],+ false,+ window,+ cx,+ );+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ let mut added = sources.clone();+ added.push(Point::new(2, 0)..Point::new(2, 0));+ assert_eq!(stored_selection_ranges(editor, cx), added);+ editor.undo_selection(&UndoSelection, window, cx);+ assert_eq!(stored_selection_ranges(editor, cx), sources);+ editor.redo_selection(&RedoSelection, window, cx);+ assert_eq!(stored_selection_ranges(editor, cx), added);+ editor.undo_selection(&UndoSelection, window, cx);+ assert_eq!(stored_selection_ranges(editor, cx), sources);+ });+ }+ }+}++#[gpui::test]+async fn test_add_selection_removing_projection_retains_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for remove_by_click in [false, true] {+ cx.set_state("a«bc\ndefgˇ»hi\nuvwxyz");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("a«bcˇ»\nd«efgˇ»hi\nu«vwxˇ»yz");+ cx.update_editor(|editor, window, cx| {+ if remove_by_click {+ editor.begin_selection(DisplayPoint::new(DisplayRow(2), 4), true, 1, window, cx);+ } else {+ add_selection_in_direction(editor, true, true, window, cx);+ }+ });+ cx.assert_editor_state("a«bcˇ»\nd«efgˇ»hi\nuvwxyz");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("a«bcˇ»\nd«efgˇ»hi\nu«vwxˇ»yz");+ }+}++#[gpui::test]+async fn test_add_selection_coalesced_source_reseeds_goal_and_history(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ cx.set_state("«abcdˇ»\nabcˇd\nx\nabcd");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("«abcdˇ»\n«abcdˇ»\nxˇ\nabcd");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("«abcdˇ»\n«abcdˇ»\n«xˇ»\naˇbcd");+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ });+ cx.assert_editor_state("«abcdˇ»\n«abcdˇ»\nxˇ\nabcd");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("«abcdˇ»\n«abcdˇ»\n«xˇ»\naˇbcd");+}++#[gpui::test]+async fn test_add_selection_replacement_discards_dead_groups_and_history(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ cx.set_state("aˇbcd\nabcd\nabcd");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ assert_eq!(+ editor.add_selections_state.as_ref().map(|state| {+ state+ .groups+ .iter()+ .map(|group| group.stack.len())+ .collect::<Vec<_>>()+ }),+ Some(vec![3])+ );+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.select_ranges([Point::new(0, 1)..Point::new(0, 1)]);+ });+ assert!(editor.add_selections_state.is_none());+ editor.move_right(&MoveRight, window, cx);+ editor.move_left(&MoveLeft, window, cx);+ assert!(editor.add_selections_state.is_none());+ assert_eq!(+ editor+ .selection_history+ .undo_stack+ .iter()+ .rev()+ .take(2)+ .map(|entry| entry+ .add_selections_state+ .as_ref()+ .map(|state| state.groups.len()))+ .collect::<Vec<_>>(),+ [None, None]+ );+ editor.undo_selection(&UndoSelection, window, cx);+ assert!(editor.add_selections_state.is_none());+ });+ cx.assert_editor_state("abˇcd\nabcd\nabcd");+ }+}++#[gpui::test]+async fn test_add_selection_cancel_reseeds_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (above, initial, cancelled, restarted) in [+ (+ false,+ "a«bc\ndefgˇ»hi\nuvwxyz",+ "a«bcˇ»\ndefghi\nuvwxyz",+ "a«bcˇ»\nd«efˇ»ghi\nuvwxyz",+ ),+ (+ true,+ "uvwxyz\na«bc\ndefgˇ»hi",+ "uvwxyz\na«bcˇ»\ndefghi",+ "u«vwˇ»xyz\na«bcˇ»\ndefghi",+ ),+ ] {+ for skip_soft_wrap in [false, true] {+ cx.set_state(initial);+ let grouped = cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ let grouped = editor+ .selections+ .ranges::<Point>(&editor.display_snapshot(cx));+ editor.cancel(&Cancel, window, cx);+ grouped+ });+ cx.assert_editor_state(cancelled);+ cx.update_editor(|editor, window, cx| {+ editor.undo_selection(&UndoSelection, window, cx);+ add_selection_in_direction(editor, !above, skip_soft_wrap, window, cx);+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ assert_add_selection_ranges(editor, &grouped, cx);+ editor.cancel(&Cancel, window, cx);+ editor.undo_selection(&UndoSelection, window, cx);+ editor.redo_selection(&RedoSelection, window, cx);+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ });+ cx.assert_editor_state(restarted);+ }+ }+}++#[gpui::test]+async fn test_add_selection_unrelated_pending_retains_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (finish_pending, cancel_pending) in [(false, false), (true, false), (false, true)] {+ cx.set_state("a«bc\ndefgˇ»hi\nuvwxyz\nabcdef\n012345");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ editor.begin_selection(DisplayPoint::new(DisplayRow(4), 0), true, 1, window, cx);+ if finish_pending {+ editor.end_selection(window, cx);+ } else if cancel_pending {+ editor.cancel(&Cancel, window, cx);+ }+ add_selection_in_direction(editor, false, true, window, cx);+ });+ let caret = if cancel_pending { "" } else { "ˇ" };+ cx.assert_editor_state(&format!(+ "a«bcˇ»\nd«efgˇ»hi\nu«vwxˇ»yz\na«bcdˇ»ef\n{caret}012345"+ ));+ }+}++#[gpui::test]+async fn test_add_selection_pending_overlap_cancel_reverses_group(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ for above in [false, true] {+ for overlap_source in [false, true] {+ for restore_history in [false, true] {+ cx.set_state("abcdef\nabcdef\nabcdef\nabcdefˇ");+ cx.update_editor(|editor, window, cx| {+ let source_row = if above { 2 } else { 1 };+ let added_row = if above { 1 } else { 2 };+ let source = Point::new(source_row, 2);+ editor.change_selections(+ SelectionEffects::no_scroll(),+ window,+ cx,+ |selections| {+ selections.select_ranges([source..source]);+ },+ );+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ begin_add_selection_overlap(+ editor,+ if overlap_source {+ source_row+ } else {+ added_row+ },+ 0..3,+ window,+ cx,+ );+ editor.cancel(&Cancel, window, cx);+ if restore_history {+ editor.undo_selection(&UndoSelection, window, cx);+ editor.redo_selection(&RedoSelection, window, cx);+ }+ assert_add_selection_ranges(+ editor,+ &[+ Point::new(1, 2)..Point::new(1, 2),+ Point::new(2, 2)..Point::new(2, 2),+ ],+ cx,+ );+ add_selection_in_direction(editor, !above, skip_soft_wrap, window, cx);+ assert_add_selection_ranges(editor, &[source..source], cx);+ editor.undo_selection(&UndoSelection, window, cx);+ editor.redo_selection(&RedoSelection, window, cx);+ assert_add_selection_ranges(editor, &[source..source], cx);+ });+ }+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_pending_overlap_commit_or_consume(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ for finish_pending in [false, true] {+ for (above, overlap_row, columns) in [+ (false, 1, [(0, 0..3), (1, 0..3), (2, 2..2)]),+ (false, 2, [(0, 2..2), (1, 0..3), (2, 0..3)]),+ (true, 1, [(1, 0..3), (2, 0..3), (3, 2..2)]),+ (true, 2, [(1, 2..2), (2, 0..3), (3, 0..3)]),+ ] {+ cx.set_state("abcdef\nabcdef\nabcdef\nabcdefˇ");+ cx.update_editor(|editor, window, cx| {+ let source = Point::new(if above { 2 } else { 1 }, 2);+ editor.change_selections(+ SelectionEffects::no_scroll(),+ window,+ cx,+ |selections| {+ selections.select_ranges([source..source]);+ },+ );+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ begin_add_selection_overlap(editor, overlap_row, 0..3, window, cx);+ if finish_pending {+ editor.end_selection(window, cx);+ }+ add_selection_in_direction(editor, !above, skip_soft_wrap, window, cx);+ let expected = columns+ .into_iter()+ .map(|(row, columns)| {+ Point::new(row, columns.start)..Point::new(row, columns.end)+ })+ .collect::<Vec<_>>();+ assert_add_selection_ranges(editor, &expected, cx);+ assert_eq!(editor.selections.pending_anchor(), None);+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_pending_overlap_multiline_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ for (above, initial, _, _) in multiline_add_selection_history_states() {+ for (cancel_pending, finish_pending) in [(true, false), (false, true), (false, false)] {+ cx.set_state(initial);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ begin_add_selection_overlap(+ editor,+ if above { 2 } else { 1 },+ 0..2,+ window,+ cx,+ );+ if cancel_pending {+ editor.cancel(&Cancel, window, cx);+ editor.undo_selection(&UndoSelection, window, cx);+ editor.redo_selection(&RedoSelection, window, cx);+ } else if finish_pending {+ editor.end_selection(window, cx);+ }+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ let columns = if cancel_pending {+ [1..3, 1..4, 1..4, 1..4]+ } else {+ [1..3, 0..4, 0..4, 1..if skip_soft_wrap { 3 } else { 4 }]+ };+ let expected = (0..4)+ .map(|row| {+ let columns = &columns[if above { 3 - row } else { row }];+ Point::new(row as u32, columns.start)+ ..Point::new(row as u32, columns.end)+ })+ .collect::<Vec<_>>();+ assert_add_selection_ranges(editor, &expected, cx);+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_pending_overlap_committed_source_changes(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (above, initial, _, _) in multiline_add_selection_history_states() {+ cx.set_state(initial);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, true, window, cx);+ begin_add_selection_overlap(editor, if above { 2 } else { 1 }, 0..2, window, cx);+ let snapshot = editor.display_snapshot(cx);+ let source_row = if above { 3 } else { 0 };+ let selections = editor+ .selections+ .disjoint_anchors()+ .iter()+ .map(|selection| {+ let mut selection =+ selection.map(|anchor| anchor.to_point(snapshot.buffer_snapshot()));+ if selection.start.row == source_row {+ selection.end.column = 2;+ }+ selection+ })+ .collect::<Vec<_>>();+ let pending = *editor.selections.pending_anchor().expect("pending overlap");+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |collection| {+ collection.select(selections);+ collection.set_pending(pending, SelectMode::Character);+ });+ editor.cancel(&Cancel, window, cx);+ add_selection_in_direction(editor, above, true, window, cx);+ let columns = [1..2, 1..4, 1..4, 1..2];+ let expected = (0..4)+ .map(|row| {+ let columns = &columns[if above { 3 - row } else { row }];+ Point::new(row as u32, columns.start)..Point::new(row as u32, columns.end)+ })+ .collect::<Vec<_>>();+ assert_add_selection_ranges(editor, &expected, cx);+ });+ }+}++#[gpui::test]+async fn test_add_selection_pending_overlap_retreat_after_buffer_edit(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ for (above, initial, _, _) in multiline_add_selection_history_states() {+ for (cancel_pending, finish_pending) in [(true, false), (false, true), (false, false)] {+ cx.set_state(initial);+ let overlap_row = if above { 2 } else { 1 };+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ begin_add_selection_overlap(editor, overlap_row, 0..2, window, cx);+ });+ cx.update_buffer(|buffer, cx| {+ let start = Point::new(overlap_row, 0);+ buffer.edit([(start..start, "ZZ")], None, cx);+ });+ cx.update_editor(|editor, window, cx| {+ editor.update_selection(+ DisplayPoint::new(DisplayRow(overlap_row), 0),+ 0,+ gpui::Point::<f32>::default(),+ window,+ cx,+ );+ if cancel_pending {+ editor.cancel(&Cancel, window, cx);+ } else if finish_pending {+ editor.end_selection(window, cx);+ }+ add_selection_in_direction(editor, above, skip_soft_wrap, window, cx);+ let columns = [1..3, 3..6, 1..4, 1..if skip_soft_wrap { 6 } else { 4 }];+ let mut expected = (0..4)+ .map(|row| {+ let columns = &columns[if above { 3 - row } else { row }];+ Point::new(row as u32, columns.start)+ ..Point::new(row as u32, columns.end)+ })+ .collect::<Vec<_>>();+ if !cancel_pending {+ expected.extend((1..3).map(|row| Point::new(row, 0)..Point::new(row, 0)));+ expected.sort_by_key(|range| range.start);+ }+ assert_add_selection_ranges(editor, &expected, cx);+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_pending_overlap_absorbs_multiline_source(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for skip_soft_wrap in [false, true] {+ for (cancel_pending, finish_pending) in [(true, false), (false, true), (false, false)] {+ cx.set_state("a«bc\ndefgˇ»hi\nuv\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ editor.begin_selection(DisplayPoint::new(DisplayRow(0), 0), true, 1, window, cx);+ editor.update_selection(+ DisplayPoint::new(DisplayRow(1), 4),+ 0,+ gpui::Point::<f32>::default(),+ window,+ cx,+ );+ if cancel_pending {+ editor.cancel(&Cancel, window, cx);+ } else if finish_pending {+ editor.end_selection(window, cx);+ }+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ let columns = if cancel_pending {+ [1..3, 1..4, 1..2, 1..4]+ } else {+ [0..3, 0..4, 0..2, 1..2]+ };+ let expected = columns+ .into_iter()+ .enumerate()+ .map(|(row, columns)| {+ Point::new(row as u32, columns.start)..Point::new(row as u32, columns.end)+ })+ .collect::<Vec<_>>();+ assert_add_selection_ranges(editor, &expected, cx);+ });+ }+ }+}++#[gpui::test]+async fn test_add_selection_goal_changes_are_group_local(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for remote in [false, true] {+ for (changed_row, columns, goal_end) in [+ (0, Some(1..2), 2),+ (1, Some(1..2), 3),+ (0, None, 4),+ (1, None, 4),+ (1, Some(1..4), 4),+ ] {+ cx.set_state(+ "a«bc\ndefgˇ»hi\nuvwxyz\nabcdef\n\na«bc\ndefgˇ»hi\nuvwxyz\nabcdef\n012345",+ );+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.insert_range(Point::new(9, 0)..Point::new(9, 0));+ });+ let snapshot = editor.display_snapshot(cx);+ let selections = editor+ .selections+ .all_unexpanded::<Point>(&snapshot)+ .into_iter()+ .filter_map(|mut selection| {+ if selection.start.row == changed_row {+ let columns = columns.as_ref()?;+ selection.start.column = columns.start;+ selection.end.column = columns.end;+ }+ Some(selection)+ })+ .collect::<Vec<_>>();+ if remote {+ let selections = selections+ .into_iter()+ .map(|selection| {+ selection.map(|point| snapshot.buffer_snapshot().anchor_before(point))+ })+ .collect();+ editor.set_selections_from_remote(selections, None, window, cx);+ } else {+ editor.change_selections(+ SelectionEffects::no_scroll(),+ window,+ cx,+ |collection| {+ collection.select(selections);+ },+ );+ }+ add_selection_in_direction(editor, false, true, window, cx);+ let expected = (0..10)+ .filter_map(|row| {+ let columns = if row == changed_row {+ columns.clone()?+ } else {+ match row {+ 0 | 5 => 1..3,+ 1 | 2 | 6 | 7 | 8 => 1..4,+ 3 => 1..goal_end,+ 9 => 0..0,+ _ => return None,+ }+ };+ Some(Point::new(row, columns.start)..Point::new(row, columns.end))+ })+ .collect::<Vec<_>>();+ assert_add_selection_ranges(editor, &expected, cx);+ });+ }+ }+}++#[gpui::test]+async fn test_add_selection_overlap_invalidates_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (pending, finish_pending) in [(false, false), (true, false), (true, true)] {+ for preceding_range in [false, true] {+ for (columns, pending_goal, inserted_goal) in+ [(0..1, 4, 4), (0..2, 3, 3), (4..4, 3, 4), (4..5, 4, 4)]+ {+ cx.set_state("a«bc\ndefgˇ»hi\nuvwxyz\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ if preceding_range {+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.insert_range(Point::new(1, 0)..Point::new(1, 1));+ });+ }+ let snapshot = editor.display_snapshot(cx);+ let range = snapshot.buffer_snapshot().anchor_before(Point::new(1, columns.start))+ ..snapshot.buffer_snapshot().anchor_before(Point::new(1, columns.end));+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ if pending {+ selections.set_pending_anchor_range(range, SelectMode::Character);+ } else {+ selections.insert_range(range);+ }+ });+ if finish_pending {+ editor.end_selection(window, cx);+ }+ add_selection_in_direction(editor, false, true, window, cx);+ let goal_end = if pending { pending_goal } else { inserted_goal };+ assert_eq!(+ editor.selections.ranges::<Point>(&editor.display_snapshot(cx))+ .into_iter()+ .filter(|range| range.start.row == 3)+ .collect::<Vec<_>>(),+ [Point::new(3, 1)..Point::new(3, goal_end)],+ "pending={pending}, finish_pending={finish_pending}, preceding_range={preceding_range}, columns={columns:?}",+ );+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_sync_preserves_unchanged_goals(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for subscribe_before in [false, true] {+ for move_source in [false, true] {+ cx.set_state("a«bc\ndefgˇ»hi\nuvwxyz\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ let (_source, _subscription) = cx.update_editor(|editor, window, cx| {+ let source = cx.new(|cx| editor.clone(window, cx));+ let subscription =+ subscribe_before.then(|| editor.sync_selections(source.clone(), cx));+ source.update(cx, |source, cx| {+ source.change_selections(+ SelectionEffects::no_scroll(),+ window,+ cx,+ |collection| {+ let mut selections = collection.all_unexpanded::<MultiBufferOffset>(+ &collection.display_snapshot(),+ );+ for selection in &mut selections {+ if move_source && selection.start == MultiBufferOffset(1) {+ selection.end = MultiBufferOffset(2);+ }+ }+ collection.select(selections);+ },+ );+ });+ let subscription =+ subscription.unwrap_or_else(|| editor.sync_selections(source.clone(), cx));+ (source, subscription)+ });+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state(if move_source {+ "a«bˇ»c\nd«efgˇ»hi\nu«vwxˇ»yz\na«bˇ»cdef"+ } else {+ "a«bcˇ»\nd«efgˇ»hi\nu«vwxˇ»yz\na«bcdˇ»ef"+ });+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_goal_reseeds_from_oldest_survivor(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ cx.set_state("a«bc\ndefgˇ»hi\nuv\nabcdef");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ let oldest_id = editor.selections.oldest_anchor().id;+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.delete(oldest_id);+ });+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("abc\nd«efgˇ»hi\nu«vˇ»\na«bcdˇ»ef");+}++#[gpui::test]+async fn test_add_selection_unwrapped_multiline_goal_follows_buffer_edits(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for add_pending in [false, true] {+ cx.set_state("a«bc\ndefgˇ»hi\nuvwxyz\nabcdefgh");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.update_buffer(|buffer, cx| {+ buffer.edit([(Point::new(1, 0)..Point::new(1, 0), "ZZ")], None, cx);+ });+ cx.update_editor(|editor, window, cx| {+ if add_pending {+ editor.begin_selection(DisplayPoint::new(DisplayRow(3), 0), true, 1, window, cx);+ editor.end_selection(window, cx);+ }+ add_selection_in_direction(editor, false, true, window, cx);+ });+ let caret = if add_pending { "ˇ" } else { "" };+ cx.assert_editor_state(&format!(+ "a«bcˇ»\nZZd«efgˇ»hi\nu«vwxˇ»yz\n{caret}a«bcdefˇ»gh"+ ));+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_multiline_goal_follows_tab_size(cx: &mut TestAppContext) {+ init_test(cx, |settings| {+ settings.defaults.tab_size = NonZeroU32::new(4);+ });+ let mut cx = EditorTestContext::new(cx).await;+ cx.set_state("a«bc\n\tˇ»defgh\nabcdefghij\nabcdefghij");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("a«bcˇ»\n«\tˇ»defgh\na«bcdˇ»efghij\nabcdefghij");+ for (tab_size, expected) in [+ (8, "a«bcˇ»\n«\tˇ»defgh\na«bcdˇ»efghij\na«bcdefghˇ»ij"),+ (4, "a«bcˇ»\n«\tˇ»defgh\na«bcdˇ»efghij\na«bcdˇ»efghij"),+ ] {+ update_test_language_settings(&mut cx, &|settings| {+ settings.defaults.tab_size = NonZeroU32::new(tab_size);+ });+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state(expected);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, true, true, window, cx);+ });+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_multiline_goal_follows_inlays(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ cx.set_state("a«bc\ndefgˇ»hi\nabcdefghij\nabcdefghij");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ let position = editor+ .buffer+ .read(cx)+ .snapshot(cx)+ .anchor_before(Point::new(1, 0));+ editor.splice_inlays(&[], vec![inlays::Inlay::mock_hint(0, position, "HH")], cx);+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("a«bcˇ»\nd«efgˇ»hi\na«bcdˇ»efghij\na«bcdefˇ»ghij");+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, true, true, window, cx);+ editor.splice_inlays(&[project::InlayId::Hint(0)], Vec::new(), cx);+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("a«bcˇ»\nd«efgˇ»hi\na«bcdˇ»efghij\na«bcdˇ»efghij");+}++#[gpui::test]+async fn test_add_selection_unwrapped_clears_pixel_goals(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ cx.set_state("abˇcdef\nabcdef");+ cx.update_editor(|editor, window, cx| {+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.move_with(&mut |_, selection| {+ selection.goal = SelectionGoal::HorizontalRange {+ start: 0.0,+ end: 200.0,+ };+ });+ });+ add_selection_in_direction(editor, false, true, window, cx);+ assert_eq!(+ editor+ .selections+ .all::<Point>(&editor.display_snapshot(cx))+ .iter()+ .map(|selection| selection.goal)+ .collect::<Vec<_>>(),+ [SelectionGoal::None, SelectionGoal::None],+ );+ });+ cx.assert_editor_state("abˇcdef\nabˇcdef");+}++#[gpui::test]+async fn test_add_selection_skips_inlay_inside_grapheme(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ for (prefix, row) in [+ (String::new(), 0),+ (format!("{}\n\n\n", "a".repeat(121)), 3),+ ] {+ cx.set_state(&format!("{prefix}👩\u{200d}💻|Z\nˇ"));+ cx.update_editor(|editor, window, cx| {+ let buffer = editor.buffer.read(cx).snapshot(cx);+ let position = buffer.anchor_before(Point::new(row, 4));+ editor.splice_inlays(&[], vec![inlays::Inlay::mock_hint(0, position, "\n")], cx);+ add_selection_in_direction(editor, true, true, window, cx);+ assert_eq!(+ editor+ .selections+ .ranges::<Point>(&editor.display_snapshot(cx)),+ [+ Point::new(row, 0)..Point::new(row, 0),+ Point::new(row + 1, 0)..Point::new(row + 1, 0)+ ]+ );+ });+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_en_dash(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;++ for columns in [[4..4, 2..2], [3..4, 1..2], [4..6, 2..4]] {+ for above in [false, true] {+ for reversed in [false, true] {+ cx.set_state("–x|Z\nab|Zˇ");+ cx.update_editor(|editor, window, cx| {+ assert_add_selection_pair(editor, columns.clone(), above, reversed, window, cx);+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_unicode_tabs(cx: &mut TestAppContext) {+ init_test(cx, |settings| {+ settings.defaults.hard_tabs = Some(true);+ settings.defaults.tab_size = Some(4.try_into().expect("nonzero tab size"));+ });+ let mut cx = EditorTestContext::new(cx).await;++ for columns in [[8..8, 4..4], [6..8, 3..4], [8..10, 4..6]] {+ for above in [false, true] {+ for reversed in [false, true] {+ cx.set_state("–é\tλ|Z\nab\tc|Zˇ");+ cx.update_editor(|editor, window, cx| {+ assert_add_selection_pair(editor, columns.clone(), above, reversed, window, cx);+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_source_range_across_wraps(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;++ for wrap_width in [None, Some(px(60.0)), Some(px(90.0))] {+ for columns in [3..18, 3..20, 18..18] {+ for above in [false, true] {+ for reversed in [false, true] {+ cx.set_state(" abcdefghijklmnop|Z\n ab cd efghijklmnop|Zˇ");+ cx.update_editor(|editor, window, cx| {+ editor.set_wrap_width(wrap_width, cx);+ if wrap_width.is_some() {+ let snapshot = editor.display_snapshot(cx);+ for row in 0..2 {+ assert_ne!(+ Point::new(row, 3).to_display_point(&snapshot).row(),+ Point::new(row, 18).to_display_point(&snapshot).row(),+ );+ }+ }+ assert_add_selection_pair(+ editor,+ [columns.clone(), columns.clone()],+ above,+ reversed,+ window,+ cx,+ );+ });+ }+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_clamp_retains_goal(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;++ for (before, intermediate, after, above) in [+ (+ "–abcˇ|Z\nx\nwxyz|Z",+ "–abcˇ|Z\nxˇ\nwxyz|Z",+ "–abcˇ|Z\nxˇ\nwxyzˇ|Z",+ false,+ ),+ (+ "wxyz|Z\nx\n–abcˇ|Z",+ "wxyz|Z\nxˇ\n–abcˇ|Z",+ "wxyzˇ|Z\nxˇ\n–abcˇ|Z",+ true,+ ),+ (+ "–a«ˇbc|Z»\nxyz\nuvwxyz",+ "–a«ˇbc|Z»\nxy«ˇz»\nuvwxyz",+ "–a«ˇbc|Z»\nxy«ˇz»\nuv«ˇwxyz»",+ false,+ ),+ (+ "uvwxyz\nxyz\n–a«bc|Zˇ»",+ "uvwxyz\nxy«zˇ»\n–a«bc|Zˇ»",+ "uv«wxyzˇ»\nxy«zˇ»\n–a«bc|Zˇ»",+ true,+ ),+ ] {+ cx.set_state(before);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, true, window, cx);+ });+ cx.assert_editor_state(intermediate);+ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, above, true, window, cx);+ });+ cx.assert_editor_state(after);+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_multiple_groups(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;+ cx.set_state("–aˇbcdef\nx\nabcdef\nabc«ˇde»f\nxy\nabcdef");++ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("–aˇbcdef\nxˇ\nabcdef\nabc«ˇde»f\nxy\nabc«ˇde»f");++ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, false, true, window, cx);+ });+ cx.assert_editor_state("–aˇbcdef\nxˇ\nabˇcdef\nabc«ˇde»f\nxy\nabc«ˇde»f");++ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, true, true, window, cx);+ });+ cx.assert_editor_state("–aˇbcdef\nxˇ\nabcdef\nabc«ˇde»f\nxy\nabcdef");++ cx.update_editor(|editor, window, cx| {+ add_selection_in_direction(editor, true, true, window, cx);+ });+ cx.assert_editor_state("–aˇbcdef\nx\nabc«ˇde»f\nabc«ˇde»f\nxy\nabcdef");+}++#[gpui::test]+async fn test_add_selection_unwrapped_mode_switch_resets_groups(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;++ for skip_soft_wrap in [false, true] {+ cx.set_state("abˇcdefghijklmnop\nqrstuvwxyzABCDEF\n0123456789abcdef");+ cx.update_editor(|editor, window, cx| {+ editor.set_wrap_width(None, cx);+ let details = editor.text_layout_details(window, cx);+ let width = editor+ .display_snapshot(cx)+ .layout_row(DisplayRow(0), &details)+ .width+ / 2.0;+ editor.set_wrap_width(Some(width), cx);+ assert_eq!(+ editor.display_text(cx),+ "abcdefgh\nijklmnop\nqrstuvwx\nyzABCDEF\n01234567\n89abcdef",+ );+ add_selection_in_direction(editor, false, skip_soft_wrap, window, cx);+ add_selection_in_direction(editor, skip_soft_wrap, !skip_soft_wrap, window, cx);+ });+ if skip_soft_wrap {+ cx.assert_editor_state("abˇcdefghijˇklmnop\nqrˇstuvwxyzABCDEF\n0123456789abcdef");+ } else {+ cx.assert_editor_state("abˇcdefghijˇklmnop\nqrˇstuvwxyzˇABCDEF\n0123456789abcdef");+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_eof_and_skipped_range_terminate(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;++ for state in [+ "abcdefghijklmnopˇ",+ "abcdefghijklmnop\nqrstuvwxyzABCDEFˇ",+ "abcdefghijkl«mnopˇ»\nabcdefgh",+ ] {+ cx.set_state(state);+ cx.update_editor(|editor, window, cx| {+ editor.set_wrap_width(None, cx);+ let details = editor.text_layout_details(window, cx);+ let width = editor+ .display_snapshot(cx)+ .layout_row(DisplayRow(0), &details)+ .width+ / 4.0;+ editor.set_wrap_width(Some(width), cx);+ assert!(editor.display_snapshot(cx).max_point().row().0 >= 3);+ for _ in 0..2 {+ add_selection_in_direction(editor, false, true, window, cx);+ }+ });+ cx.assert_editor_state(state);+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_inlay_rows_and_widths(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;++ for columns in [[1..1, 3..3], [1..3, 3..5]] {+ for above in [false, true] {+ cx.set_state("a|Z\nabc|Zˇ");+ cx.update_editor(|editor, window, cx| {+ let position = editor+ .buffer+ .read(cx)+ .snapshot(cx)+ .anchor_before(Point::new(0, 0));+ editor.splice_inlays(+ &[],+ vec![inlays::Inlay::mock_hint(0, position, "hint\n–é")],+ cx,+ );+ assert_eq!(editor.display_text(cx), "hint\n–éa|Z\nabc|Z");+ assert_add_selection_pair(editor, columns.clone(), above, false, window, cx);+ editor.splice_inlays(&[project::InlayId::Hint(0)], Vec::new(), cx);+ });+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_folded_target_boundaries(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;++ for (source, target) in [(4..4, 2..2), (5..5, 8..8), (4..5, 2..8)] {+ for above in [false, true] {+ for reversed in [false, true] {+ cx.set_state(if above {+ "abhidden|Z\na–|Zˇ"+ } else {+ "a–|Z\nabhidden|Zˇ"+ });+ cx.update_editor(|editor, window, cx| {+ let target_row = u32::from(!above);+ editor.fold_creases(+ vec![Crease::simple(+ Point::new(target_row, 2)..Point::new(target_row, 8),+ FoldPlaceholder::test(),+ )],+ true,+ window,+ cx,+ );+ assert_eq!(+ editor.display_text(cx),+ if above {+ "ab⋯|Z\na–|Z"+ } else {+ "a–|Z\nab⋯|Z"+ }+ );+ let columns = if above {+ [target.clone(), source.clone()]+ } else {+ [source.clone(), target.clone()]+ };+ assert_add_selection_pair(editor, columns, above, reversed, window, cx);+ });+ }+ }+ }+}++#[gpui::test]+async fn test_add_selection_unwrapped_multiline_fold_rows(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorTestContext::new(cx).await;++ for above in [false, true] {+ cx.set_state(if above {+ "abhidden\nhidden\n|Z\na–ˇ|Z"+ } else {+ "a–ˇ|Z\nabhidden\nhidden\n|Z"+ });+ cx.update_editor(|editor, window, cx| {+ let target_row = u32::from(!above);+ editor.fold_creases(+ vec![Crease::simple(+ Point::new(target_row, 2)..Point::new(target_row + 2, 0),+ FoldPlaceholder::test(),+ )],+ true,+ window,+ cx,+ );+ assert_eq!(+ editor.display_text(cx),+ if above {+ "ab⋯|Z\na–|Z"+ } else {+ "a–|Z\nab⋯|Z"+ }+ );+ add_selection_in_direction(editor, above, true, window, cx);+ });+ cx.assert_editor_state(if above {+ "abˇhidden\nhidden\n|Z\na–ˇ|Z"+ } else {+ "a–ˇ|Z\nabˇhidden\nhidden\n|Z"+ });+ }+}+/// A different number of tabs can align the same column on each row, so a cursor has to/// be placed by the column the tabs expand to. Counting a tab as a single column lands it/// wherever that many characters happen to reach on the next row.@@ -47171,3 +49148,125 @@ fn document_highlight_count(cx: &mut EditorLspTestContext) -> usize {.map_or(0, |(_, ranges)| ranges.len())})}++#[track_caller]+fn assert_add_selection_pair(+ editor: &mut Editor,+ columns: [Range<u32>; 2],+ above: bool,+ reversed: bool,+ window: &mut Window,+ cx: &mut Context<Editor>,+) {+ let ranges = columns+ .into_iter()+ .enumerate()+ .map(|(row, columns)| {+ Point::new(row as u32, columns.start)..Point::new(row as u32, columns.end)+ })+ .collect::<Vec<_>>();+ let source = &ranges[usize::from(above)];+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {+ selections.select_ranges([if reversed {+ source.end..source.start+ } else {+ source.clone()+ }]);+ });+ add_selection_in_direction(editor, above, true, window, cx);+ let selections = editor.selections.all::<Point>(&editor.display_snapshot(cx));+ assert_eq!(+ selections+ .iter()+ .map(|selection| (selection.range(), selection.reversed))+ .collect::<Vec<_>>(),+ ranges+ .into_iter()+ .map(|range| {+ let reversed = reversed && !range.is_empty();+ (range, reversed)+ })+ .collect::<Vec<_>>(),+ "above={above}, reversed={reversed}",+ );+}++#[track_caller]+fn assert_add_selection_ranges(+ editor: &mut Editor,+ expected: &[Range<Point>],+ cx: &mut Context<Editor>,+) {+ assert_eq!(+ editor+ .selections+ .ranges::<Point>(&editor.display_snapshot(cx)),+ expected,+ );+}++fn stored_selection_ranges(editor: &Editor, cx: &App) -> Vec<Range<Point>> {+ let buffer = editor.buffer.read(cx).snapshot(cx);+ editor+ .selections+ .disjoint_anchors()+ .iter()+ .chain(editor.selections.pending_anchor())+ .map(|selection| selection.range().to_point(&buffer))+ .collect()+}++fn add_selection_in_direction(+ editor: &mut Editor,+ above: bool,+ skip_soft_wrap: bool,+ window: &mut Window,+ cx: &mut Context<Editor>,+) {+ if above {+ editor.add_selection_above(&AddSelectionAbove { skip_soft_wrap }, window, cx);+ } else {+ editor.add_selection_below(&AddSelectionBelow { skip_soft_wrap }, window, cx);+ }+}++fn begin_add_selection_overlap(+ editor: &mut Editor,+ row: u32,+ columns: Range<u32>,+ window: &mut Window,+ cx: &mut Context<Editor>,+) {+ editor.begin_selection(+ DisplayPoint::new(DisplayRow(row), columns.start),+ true,+ 1,+ window,+ cx,+ );+ editor.update_selection(+ DisplayPoint::new(DisplayRow(row), columns.end),+ 0,+ gpui::Point::<f32>::default(),+ window,+ cx,+ );+}++fn multiline_add_selection_history_states() -> [(bool, &'static str, &'static str, &'static str); 2]+{+ [+ (+ false,+ "a«bc\ndefgˇ»hi\nuvwxyz\nabcdef",+ "a«bcˇ»\nd«efgˇ»hi\nu«vwxˇ»yz\nabcdef",+ "a«bcˇ»\nd«efgˇ»hi\nu«vwxˇ»yz\na«bcdˇ»ef",+ ),+ (+ true,+ "abcdef\nuvwxyz\ndefg«hi\naˇ»bc",+ "abcdef\nu«vwxˇ»yz\nd«efgˇ»hi\na«bcˇ»",+ "a«bcdˇ»ef\nu«vwxˇ»yz\nd«efgˇ»hi\na«bcˇ»",+ ),+ ]+}diff --git a/crates/editor/src/element/mouse.rs b/crates/editor/src/element/mouse.rsindex c82edb9f02c..52f9677d391 100644--- a/crates/editor/src/element/mouse.rs+++ b/crates/editor/src/element/mouse.rs@@ -14,7 +14,7 @@ use project::DisableAiSettings;use settings::Settings;use sum_tree::Bias;use text::SelectionGoal;-use util::{RangeExt, debug_panic, post_inc};+use util::{RangeExt, debug_panic};use super::{EditorElement, EditorLayout, LineNumberLayout, PositionMap, SplitSide};use crate::{@@ -1090,7 +1090,7 @@ impl EditorElement {);if mouse_down_time.elapsed() >= drag_and_drop_delay {let drop_cursor = Selection {- id: post_inc(&mut editor.selections.next_selection_id()),+ id: editor.selections.next_selection_id(),start: drop_anchor,end: drop_anchor,reversed: false,diff --git a/crates/editor/src/fold.rs b/crates/editor/src/fold.rsindex c5b6459bc7f..73aa6b30586 100644--- a/crates/editor/src/fold.rs+++ b/crates/editor/src/fold.rs@@ -640,11 +640,15 @@ impl Editor {});let snapshot = self.display_snapshot(cx);- self.selections.change_with(&snapshot, |selections| {+ let previous = self.selections.disjoint_anchors_arc();+ let (changed, ()) = self.selections.change_with(&snapshot, |selections| {for buffer_id in ids_to_fold.iter().copied() {selections.remove_selections_from_buffer(buffer_id);}});+ if changed {+ self.invalidate_add_selection_goals_after_change(Some(&previous));+ }cx.emit(EditorEvent::BufferFoldToggled {ids: ids_to_fold,diff --git a/crates/editor/src/selection.rs b/crates/editor/src/selection.rsindex d8d54ba48ce..875faf98112 100644--- a/crates/editor/src/selection.rs+++ b/crates/editor/src/selection.rs@@ -1,4 +1,5 @@use super::*;+use crate::columnar_selection::ColumnarSelectionRows;impl Editor {pub fn sync_selections(@@ -6,45 +7,30 @@ impl Editor {other: Entity<Editor>,cx: &mut Context<Self>,) -> gpui::Subscription {- let other_selections = other.read(cx).selections.disjoint_anchors().to_vec();- if !other_selections.is_empty() {- self.selections- .change_with(&self.display_snapshot(cx), |selections| {- selections.select_anchors(other_selections);- });- }+ self.sync_selections_from(other.read(cx).selections.disjoint_anchors().to_vec(), cx);- let other_subscription = cx.subscribe(&other, |this, other, other_evt, cx| {- if let EditorEvent::SelectionsChanged { local: true } = other_evt {- let other_selections = other.read(cx).selections.disjoint_anchors().to_vec();- if other_selections.is_empty() {- return;- }- let snapshot = this.display_snapshot(cx);- this.selections.change_with(&snapshot, |selections| {- selections.select_anchors(other_selections);- });+ let other_subscription = cx.subscribe(&other, |editor, other, event, cx| {+ if let EditorEvent::SelectionsChanged { local: true } = event {+ editor.sync_selections_from(+ other.read(cx).selections.disjoint_anchors().to_vec(),+ cx,+ );}});- let this_subscription = cx.subscribe_self::<EditorEvent>(move |this, this_evt, cx| {- if let EditorEvent::SelectionsChanged { local: true } = this_evt {- let these_selections = this.selections.disjoint_anchors().to_vec();- if these_selections.is_empty() {+ let editor_subscription = cx.subscribe_self::<EditorEvent>(move |editor, event, cx| {+ if let EditorEvent::SelectionsChanged { local: true } = event {+ if editor.selections.disjoint_anchors().is_empty() {return;}+ let selections = editor.selections.disjoint_anchors().to_vec();other.update(cx, |other_editor, cx| {- let snapshot = other_editor.display_snapshot(cx);- other_editor- .selections- .change_with(&snapshot, |selections| {- selections.select_anchors(these_selections);- })+ other_editor.sync_selections_from(selections, cx);});}});- Subscription::join(other_subscription, this_subscription)+ Subscription::join(other_subscription, editor_subscription)}/// Changes selections using the provided mutation function. Changes to `self.selections` occur@@ -57,20 +43,7 @@ impl Editor {cx: &mut Context<Self>,change: impl FnOnce(&mut MutableSelectionsCollection<'_, '_>) -> R,) -> R {- let snapshot = self.display_snapshot(cx);- if let Some(state) = &mut self.deferred_selection_effects_state {- state.effects.scroll = effects.scroll.or(state.effects.scroll);- state.effects.completions = effects.completions;- state.effects.nav_history = effects.nav_history.or(state.effects.nav_history);- let (changed, result) = self.selections.change_with(&snapshot, change);- state.changed |= changed;- return result;- }- let mut state = self.prepare_selection_effects(effects);- let (changed, result) = self.selections.change_with(&snapshot, change);- state.changed = state.changed || changed;- self.apply_selection_effects(state, window, cx);- result+ self.change_selections_with_history(effects, None, window, cx, change)}/// Re-resolves selection anchors so they reference live buffer fragments.@@ -86,10 +59,9 @@ impl Editor {pub fn refresh_selection_anchors(&mut self, cx: &mut Context<Self>) {let snapshot = self.display_snapshot(cx);let selections = self.selections.all::<MultiBufferOffset>(&snapshot);- self.selections- .change_with(&snapshot, |selection_collection| {- selection_collection.select(selections);- });+ self.change_selections_without_effects(&snapshot, |selection_collection| {+ selection_collection.select(selections);+ });}/// Defers the effects of selection change, so that the effects of multiple calls to@@ -163,15 +135,14 @@ impl Editor {cx: &mut Context<Self>,) {let old_cursor_position = self.selections.newest_anchor().head();- self.selections- .change_with(&self.display_snapshot(cx), |s| {- s.select_anchors(selections);- if let Some(pending_selection) = pending_selection {- s.set_pending(pending_selection, SelectMode::Character);- } else {- s.clear_pending();- }- });+ self.change_selections_without_effects(&self.display_snapshot(cx), |s| {+ s.select_anchors(selections);+ if let Some(pending_selection) = pending_selection {+ s.set_pending(pending_selection, SelectMode::Character);+ } else {+ s.clear_pending();+ }+ });self.selections_did_change(false,&old_cursor_position,@@ -414,11 +385,11 @@ impl Editor {if !select_prev_state.done {let first_selection = selections.iter()- .min_by_key(|s| s.id)+ .min_by_key(|selection| selection.id).context("missing selection for select previous action")?;let last_selection = selections.iter()- .max_by_key(|s| s.id)+ .max_by_key(|selection| selection.id).context("missing selection for select previous action")?;let mut next_selected_range = None;// When we're iterating matches backwards, the oldest match will actually be the furthest one in the buffer.@@ -1099,7 +1070,7 @@ impl Editor {SelectionEffects::scroll(Autoscroll::newest()),window,cx,- |s| s.select_anchors(entry.selections.to_vec()),+ |s| s.select_anchors_unexpanded(entry.selections.to_vec()),);});self.selection_history.mode = SelectionHistoryMode::Normal;@@ -1124,7 +1095,7 @@ impl Editor {SelectionEffects::scroll(Autoscroll::newest()),window,cx,- |s| s.select_anchors(entry.selections.to_vec()),+ |s| s.select_anchors_unexpanded(entry.selections.to_vec()),);});self.selection_history.mode = SelectionHistoryMode::Normal;@@ -1606,9 +1577,6 @@ impl Editor {.display_map.update(cx, |display_map, cx| display_map.snapshot(cx));let buffer = display_map.buffer_snapshot();- if self.selections.count() == 1 {- self.add_selections_state = None;- }self.select_next_state = None;self.select_prev_state = None;self.select_syntax_node_history.try_clear();@@ -1761,17 +1729,13 @@ impl Editor {fn prepare_selection_effects(&self,effects: SelectionEffects,+ history_entry: Option<SelectionHistoryEntry>,) -> DeferredSelectionEffectsState {DeferredSelectionEffectsState {changed: false,effects,old_cursor_position: self.selections.newest_anchor().head(),- history_entry: SelectionHistoryEntry {- selections: self.selections.disjoint_anchors_arc(),- select_next_state: self.select_next_state.clone(),- select_prev_state: self.select_prev_state.clone(),- add_selections_state: self.add_selections_state.clone(),- },+ history_entry: history_entry.unwrap_or_else(|| self.selection_history_entry()),}}@@ -1952,6 +1916,180 @@ impl Editor {))}+ pub(super) fn invalidate_add_selection_goals_after_change(+ &mut self,+ previous: Option<&[Selection<Anchor>]>,+ ) {+ if self.add_selections_state.is_none() {+ return;+ }+ let Some(previous) = previous else {+ self.add_selections_state = None;+ return;+ };+ let current = self+ .selections+ .disjoint_anchors()+ .iter()+ .map(|selection| (selection.id, selection))+ .collect::<HashMap<_, _>>();+ let unchanged = previous+ .iter()+ .filter(|selection| current.get(&selection.id) == Some(selection))+ .map(|selection| selection.id)+ .collect::<HashSet<_>>();+ let removed = previous+ .iter()+ .filter(|selection| !current.contains_key(&selection.id))+ .map(|selection| selection.id)+ .collect::<HashSet<_>>();+ if let Some(state) = &mut self.add_selections_state {+ Self::retain_add_selection_goals(state, &unchanged, &removed, ¤t);+ if state.groups.is_empty() {+ self.add_selections_state = None;+ }+ }+ }++ fn sync_selections_from(&mut self, selections: Vec<Selection<Anchor>>, cx: &mut Context<Self>) {+ if !selections.is_empty() {+ self.change_selections_without_effects(&self.display_snapshot(cx), |collection| {+ collection.select_anchors(selections);+ });+ }+ }++ fn retain_add_selection_goals<T>(+ state: &mut AddSelectionsState,+ unchanged: &HashSet<usize>,+ removed: &HashSet<usize>,+ current: &HashMap<usize, &Selection<T>>,+ ) {+ let skip_soft_wrap = state.skip_soft_wrap;+ state.groups.retain_mut(|group| {+ if group.stack.first().is_none_or(|id| !unchanged.contains(id))+ || group+ .stack+ .iter()+ .any(|id| !unchanged.contains(id) && !removed.contains(id))+ {+ group.goal_source = None;+ }+ group.stack.retain(|id| current.contains_key(id));+ !group.stack.is_empty() && (skip_soft_wrap || group.stack.len() > 1)+ });+ }++ fn reconcile_add_selection_groups(+ state: &mut AddSelectionsState,+ previous: &[Selection<Point>],+ current: &[Selection<Point>],+ ) {+ let current_by_id = current+ .iter()+ .map(|selection| (selection.id, selection))+ .collect::<HashMap<_, _>>();+ let mut unchanged = HashSet::default();+ let mut removed = HashSet::default();+ for selection in previous {+ if let Some(current) = current_by_id.get(&selection.id) {+ if **current == *selection {+ unchanged.insert(selection.id);+ }+ } else {+ let index = current.partition_point(|current| current.end < selection.start);+ let overlaps = current+ .iter()+ .skip(index)+ .take_while(|current| current.start <= selection.end)+ .any(|current| {+ if current.is_empty() || selection.is_empty() {+ current.start <= selection.end && selection.start <= current.end+ } else {+ current.start < selection.end && selection.start < current.end+ }+ });+ if !overlaps {+ removed.insert(selection.id);+ }+ }+ }+ Self::retain_add_selection_goals(state, &unchanged, &removed, ¤t_by_id);+ }++ fn resolve_add_selection_anchors(+ selections: &[Selection<Anchor>],+ snapshot: &DisplaySnapshot,+ ) -> Vec<Selection<Point>> {+ selections+ .iter()+ .filter(|selection| {+ snapshot.can_resolve(&selection.start) && snapshot.can_resolve(&selection.end)+ })+ .map(|selection| selection.map(|anchor| anchor.to_point(snapshot.buffer_snapshot())))+ .collect()+ }++ fn change_selections_without_effects<R>(+ &mut self,+ snapshot: &DisplaySnapshot,+ change: impl FnOnce(&mut MutableSelectionsCollection<'_, '_>) -> R,+ ) -> (bool, R) {+ let previous = self+ .add_selections_state+ .as_ref()+ .map(|_| self.selections.disjoint_anchors_arc());+ let (changed, result) = self.selections.change_with(snapshot, change);+ if changed+ && let Some(previous) = previous+ && let Some(state) = &mut self.add_selections_state+ {+ let previous = Self::resolve_add_selection_anchors(&previous, snapshot);+ let current =+ Self::resolve_add_selection_anchors(self.selections.disjoint_anchors(), snapshot);+ Self::reconcile_add_selection_groups(state, &previous, ¤t);+ if state.groups.is_empty() {+ self.add_selections_state = None;+ }+ }+ (changed, result)+ }++ fn selection_history_entry(&self) -> SelectionHistoryEntry {+ SelectionHistoryEntry {+ selections: self.selections.disjoint_anchors_arc(),+ select_next_state: self.select_next_state.clone(),+ select_prev_state: self.select_prev_state.clone(),+ add_selections_state: self.add_selections_state.clone(),+ }+ }++ fn change_selections_with_history<R>(+ &mut self,+ effects: SelectionEffects,+ history_entry: Option<SelectionHistoryEntry>,+ window: &mut Window,+ cx: &mut Context<Self>,+ change: impl FnOnce(&mut MutableSelectionsCollection<'_, '_>) -> R,+ ) -> R {+ let snapshot = self.display_snapshot(cx);+ if self.deferred_selection_effects_state.is_some() {+ let (changed, result) = self.change_selections_without_effects(&snapshot, change);+ if let Some(state) = &mut self.deferred_selection_effects_state {+ state.effects.scroll = effects.scroll.or(state.effects.scroll);+ state.effects.completions = effects.completions;+ state.effects.nav_history = effects.nav_history.or(state.effects.nav_history);+ state.changed |= changed;+ }+ return result;+ }+ let mut state = self.prepare_selection_effects(effects, history_entry);+ let (changed, result) = self.change_selections_without_effects(&snapshot, change);+ state.changed = state.changed || changed;+ self.apply_selection_effects(state, window, cx);+ result+ }+fn add_selection(&mut self,above: bool,@@ -1960,54 +2098,208 @@ impl Editor {cx: &mut Context<Self>,) {let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));- let all_selections = self.selections.all::<Point>(&display_map);let text_layout_details = self.text_layout_details(window, cx);-- let (mut columnar_selections, new_selections_to_columnarize) = {- if let Some(state) = self.add_selections_state.as_ref() {- let columnar_selection_ids: HashSet<_> = state- .groups- .iter()- .flat_map(|group| group.stack.iter())- .copied()- .collect();-- all_selections- .into_iter()- .partition(|s| columnar_selection_ids.contains(&s.id))+ let buffer = display_map.buffer_snapshot();+ let all_selections = self.selections.all_unexpanded::<Point>(&display_map);+ let goal_source_for_selection = |selection: &Selection<Point>| {+ let end_bias = if selection.is_empty() {+ Bias::Right} else {- (Vec::new(), all_selections)- }+ Bias::Left+ };+ buffer.anchor_after(selection.start)..buffer.anchor_at(selection.end, end_bias)};+ let history_entry = self+ .deferred_selection_effects_state+ .is_none()+ .then(|| self.selection_history_entry());+ if self+ .add_selections_state+ .as_ref()+ .is_some_and(|state| state.skip_soft_wrap != skip_soft_wrap)+ {+ self.add_selections_state = None;+ }let mut state = self.add_selections_state.take()- .unwrap_or_else(|| AddSelectionsState { groups: Vec::new() });-- for selection in new_selections_to_columnarize {+ .unwrap_or_else(|| AddSelectionsState {+ groups: Vec::new(),+ skip_soft_wrap,+ });+ if !state.groups.is_empty() {+ let previous = Self::resolve_add_selection_anchors(+ self.selections.disjoint_anchors(),+ &display_map,+ );+ Self::reconcile_add_selection_groups(&mut state, &previous, &all_selections);+ }+ let columnar_selection_ids = state+ .groups+ .iter()+ .flat_map(|group| group.stack.iter())+ .copied()+ .collect::<HashSet<_>>();+ let mut columnar_rows = ColumnarSelectionRows::new(&display_map);+ let (mut columnar_selections, new_selections_to_columnarize) =+ all_selections+ .into_iter()+ .partition::<Vec<_>, _>(|selection| columnar_selection_ids.contains(&selection.id));++ let mut goal_columns_by_selection_id = HashMap::default();+ let mut projected_selections = Vec::new();+ let mut projection_counts = vec![None; new_selections_to_columnarize.len()];+ if skip_soft_wrap {+ let selections_by_id = columnar_selections+ .iter()+ .map(|selection| (selection.id, selection))+ .collect::<HashMap<_, _>>();+ let mut sources = Vec::new();+ for group in &mut state.groups {+ let Some(oldest_selection) =+ group.stack.first().and_then(|id| selections_by_id.get(id))+ else {+ continue;+ };+ if group.goal_source.as_ref().is_some_and(|source| {+ !buffer.can_resolve(&source.start) || !buffer.can_resolve(&source.end)+ }) {+ group.goal_source = None;+ }+ let source = group+ .goal_source+ .get_or_insert_with(|| goal_source_for_selection(oldest_selection));+ if let Some(last_id) = group.stack.last() {+ sources.push((*last_id, source.to_point(buffer)));+ }+ }+ sources.extend(+ new_selections_to_columnarize+ .iter()+ .map(|selection| (selection.id, selection.range())),+ );+ let ranges = sources+ .iter()+ .map(|(_, range)| range.clone())+ .collect::<Vec<_>>();+ goal_columns_by_selection_id.extend(+ sources+ .iter()+ .map(|(id, _)| *id)+ .zip(columnar_rows.columns_for_ranges(&ranges)),+ );+ let tabs = display_map.tab_snapshot();+ let mut queries = Vec::new();+ for (selection, projection_count) in new_selections_to_columnarize+ .iter()+ .zip(&mut projection_counts)+ {+ let start = tabs.point_to_tab_point(selection.start, Bias::Left);+ let end = tabs.point_to_tab_point(selection.end, Bias::Left);+ if start.row() != end.row()+ || display_map+ .is_block_line(selection.start.to_display_point(&display_map).row())+ {+ let columns = &goal_columns_by_selection_id[&selection.id];+ let query_start = queries.len();+ let mut row = start.row();+ loop {+ let last_row =+ if let Some(hidden) = display_map.fully_replaced_tab_rows(row) {+ *hidden.end()+ } else {+ queries.push((row, columns.clone(), selection.reversed));+ row+ };+ if last_row >= end.row() {+ break;+ }+ row = last_row + 1;+ }+ *projection_count = Some(queries.len() - query_start);+ }+ }+ projected_selections = self+ .selections+ .build_columnar_selections_from_tab_expanded_columns(&mut columnar_rows, &queries);+ }+ let mut projected_selections = projected_selections.into_iter();+ for (selection, projection_count) in new_selections_to_columnarize+ .into_iter()+ .zip(projection_counts)+ {+ if skip_soft_wrap {+ let goal_source = Some(goal_source_for_selection(&selection));+ let mut stack = Vec::new();+ if let Some(count) = projection_count {+ for selection in projected_selections.by_ref().take(count).flatten() {+ stack.push(selection.id);+ columnar_selections.push(selection);+ }+ } else {+ stack.push(selection.id);+ columnar_selections.push(selection);+ }+ if !stack.is_empty() {+ if above {+ stack.reverse();+ }+ if let Some(columns) = goal_columns_by_selection_id.remove(&selection.id)+ && let Some(last_id) = stack.last()+ {+ goal_columns_by_selection_id.insert(*last_id, columns);+ }+ state.groups.push(AddSelectionsGroup {+ above,+ stack,+ goal_source,+ });+ } else {+ columnar_selections.push(selection);+ }+ continue;+ }let range = selection.display_range(&display_map).sorted();let start_x = display_map.x_for_display_point(range.start, &text_layout_details);let end_x = display_map.x_for_display_point(range.end, &text_layout_details);let positions = start_x.min(end_x)..start_x.max(end_x);let mut stack = Vec::new();- for row in range.start.row().0..=range.end.row().0 {- if let Some(selection) = self.selections.build_columnar_selection(- &display_map,- DisplayRow(row),- &positions,- selection.reversed,- &text_layout_details,- ) {- stack.push(selection.id);- columnar_selections.push(selection);+ if range.start.row() == range.end.row() && !display_map.is_block_line(range.start.row())+ {+ stack.push(selection.id);+ columnar_selections.push(Selection {+ goal: SelectionGoal::HorizontalRange {+ start: positions.start.into(),+ end: positions.end.into(),+ },+ ..selection+ });+ } else {+ for row in range.start.row().0..=range.end.row().0 {+ if let Some(selection) = self.selections.build_columnar_selection(+ &display_map,+ DisplayRow(row),+ &positions,+ selection.reversed,+ &text_layout_details,+ ) {+ stack.push(selection.id);+ columnar_selections.push(selection);+ }}}if !stack.is_empty() {if above {stack.reverse();}- state.groups.push(AddSelectionsGroup { above, stack });+ state.groups.push(AddSelectionsGroup {+ above,+ stack,+ goal_source: None,+ });+ } else {+ columnar_selections.push(selection);}}@@ -2018,31 +2310,11 @@ impl Editor {display_map.max_point().row()};- // When `skip_soft_wrap` is true, we place new selections by column rather than- // pixel position, so we need to keep track of the column range of the oldest- // selection in each group, because intermediate selections may have been- // clamped to shorter lines. Columns are counted with tabs expanded so that- // tab-aligned code lines up the way it renders.- let mut goal_columns_by_selection_id = if skip_soft_wrap {- let mut map = HashMap::default();- for group in state.groups.iter() {- if let Some(oldest_id) = group.stack.first() {- if let Some(oldest_selection) =- columnar_selections.iter().find(|s| s.id == *oldest_id)- {- let start_col = display_map.tab_expanded_column(oldest_selection.start);- let end_col = display_map.tab_expanded_column(oldest_selection.end);- let goal_columns = start_col.min(end_col)..start_col.max(end_col);- for id in &group.stack {- map.insert(*id, goal_columns.clone());- }- }- }+ if skip_soft_wrap {+ for selection in &mut columnar_selections {+ selection.goal = SelectionGoal::None;}- map- } else {- HashMap::default()- };+ }let mut last_added_item_per_group = HashMap::default();for group in state.groups.iter_mut() {@@ -2051,41 +2323,58 @@ impl Editor {}}+ let mut next_logical_selections = HashMap::default();+ if skip_soft_wrap {+ let queries = columnar_selections+ .iter()+ .filter_map(|selection| {+ let group = last_added_item_per_group.get_mut(&selection.id)?;+ if group.stack.len() == 1 {+ group.above = above;+ }+ (group.above == above).then(|| {+ (+ *selection,+ goal_columns_by_selection_id[&selection.id].clone(),+ )+ })+ })+ .collect::<Vec<_>>();+ next_logical_selections.extend(queries.iter().map(|(selection, _)| selection.id).zip(+ self.selections.find_next_columnar_selections_by_buffer_row(+ &display_map,+ &mut columnar_rows,+ &queries,+ above,+ ),+ ));+ }+for selection in columnar_selections {if let Some(group) = last_added_item_per_group.get_mut(&selection.id) {+ if skip_soft_wrap && group.stack.len() == 1 {+ group.above = above;+ }if above == group.above {- let range = selection.display_range(&display_map).sorted();- debug_assert_eq!(range.start.row(), range.end.row());- let row = range.start.row();- let positions =- if let SelectionGoal::HorizontalRange { start, end } = selection.goal {- Pixels::from(start)..Pixels::from(end)- } else {- let start_x =- display_map.x_for_display_point(range.start, &text_layout_details);- let end_x =- display_map.x_for_display_point(range.end, &text_layout_details);- start_x.min(end_x)..start_x.max(end_x)- };-let maybe_new_selection = if skip_soft_wrap {- let goal_columns = goal_columns_by_selection_id- .remove(&selection.id)- .unwrap_or_else(|| {- let start_col = display_map.tab_expanded_column(selection.start);- let end_col = display_map.tab_expanded_column(selection.end);- start_col.min(end_col)..start_col.max(end_col)- });- self.selections.find_next_columnar_selection_by_buffer_row(- &display_map,- row,- end_row,- above,- &goal_columns,- selection.reversed,- &text_layout_details,- )+ next_logical_selections.remove(&selection.id).flatten()} else {+ let range = selection.display_range(&display_map).sorted();+ let row = if above {+ range.start.row()+ } else {+ range.end.row()+ };+ let positions =+ if let SelectionGoal::HorizontalRange { start, end } = selection.goal {+ Pixels::from(start)..Pixels::from(end)+ } else {+ let start_x = display_map+ .x_for_display_point(range.start, &text_layout_details);+ let end_x = display_map+ .x_for_display_point(range.end, &text_layout_details);+ start_x.min(end_x)..start_x.max(end_x)+ };self.selections.find_next_columnar_selection_by_display_row(&display_map,row,@@ -2117,23 +2406,17 @@ impl Editor {}}- self.change_selections(Default::default(), window, cx, |s| {- s.select(final_selections);- });-- let final_selection_ids: HashSet<_> = self- .selections- .all::<Point>(&display_map)- .iter()- .map(|s| s.id)- .collect();- state.groups.retain_mut(|group| {- // selections might get merged above so we remove invalid items from stacks- group.stack.retain(|id| final_selection_ids.contains(id));+ let unmerged_selections = final_selections.clone();+ self.change_selections_with_history(+ SelectionEffects::default(),+ history_entry,+ window,+ cx,+ |selections| selections.select(final_selections),+ );- // single selection in stack can be treated as initial state- group.stack.len() > 1- });+ let current = self.selections.all_unexpanded::<Point>(&display_map);+ Self::reconcile_add_selection_groups(&mut state, &unmerged_selections, ¤t);if !state.groups.is_empty() {self.add_selections_state = Some(state);@@ -2187,11 +2470,11 @@ impl Editor {if !select_next_state.done {let first_selection = selections.iter()- .min_by_key(|s| s.id)+ .min_by_key(|selection| selection.id).context("missing selection for select next action")?;let last_selection = selections.iter()- .max_by_key(|s| s.id)+ .max_by_key(|selection| selection.id).context("missing selection for select next action")?;let mut next_selected_range = None;diff --git a/crates/editor/src/selections_collection.rs b/crates/editor/src/selections_collection.rsindex b2e32fd4c75..f358bb6b781 100644--- a/crates/editor/src/selections_collection.rs+++ b/crates/editor/src/selections_collection.rs@@ -1,5 +1,7 @@use std::{- cmp, fmt, iter, mem,+ cmp,+ collections::BTreeMap,+ fmt, iter, mem,ops::{AddAssign, Deref, DerefMut, Range, Sub},sync::Arc,};@@ -7,11 +9,11 @@ use std::{use gpui::Pixels;use itertools::{Either, Itertools as _};use language::{Bias, Point, Selection, SelectionGoal};-use multi_buffer::{MultiBufferDimension, MultiBufferOffset, MultiBufferRow, ToPoint};-use util::post_inc;+use multi_buffer::{MultiBufferDimension, MultiBufferOffset, ToPoint};use crate::{Anchor, DisplayPoint, DisplayRow, MultiBufferSnapshot, SelectMode, ToOffset,+ columnar_selection::ColumnarSelectionRows,display_map::{DisplaySnapshot, ToDisplayPoint},movement::TextLayoutDetails,};@@ -115,6 +117,13 @@ impl SelectionsCollection {resolve_selections_wrapping_blocks(self.pending_anchor(), &snapshot).next()}+ pub(crate) fn all_unexpanded<D>(&self, snapshot: &DisplaySnapshot) -> Vec<Selection<D>>+ where+ D: MultiBufferDimension + Sub + AddAssign<<D as Sub>::Output> + Ord,+ {+ self.all_iter(snapshot, false).collect()+ }+pub(crate) fn pending_mode(&self) -> Option<SelectMode> {self.pending.as_ref().map(|pending| pending.mode.clone())}@@ -123,19 +132,21 @@ impl SelectionsCollection {whereD: MultiBufferDimension + Sub + AddAssign<<D as Sub>::Output> + Ord,{- self.all_iter(snapshot).collect()+ self.all_iter(snapshot, true).collect()}fn all_iter<'a, D>(&'a self,snapshot: &'a DisplaySnapshot,+ expand_blocks: bool,) -> impl 'a + Iterator<Item = Selection<D>>whereD: 'a + MultiBufferDimension + Sub + AddAssign<<D as Sub>::Output> + Ord,{let mut disjoint =- resolve_selections_wrapping_blocks::<D, _>(self.disjoint.iter(), snapshot).peekable();- let mut pending_opt = self.pending::<D>(snapshot);+ resolve_selections::<D, _>(self.disjoint.iter(), snapshot, expand_blocks).peekable();+ let mut pending_opt =+ resolve_selections::<D, _>(self.pending_anchor(), snapshot, expand_blocks).next();iter::from_fn(move || {if let Some(pending) = pending_opt.as_mut() {while let Some(next_selection) = disjoint.peek() {@@ -347,7 +358,7 @@ impl SelectionsCollection {.next().unwrap();}- self.all_iter(snapshot).next().unwrap()+ self.all_iter(snapshot, true).next().unwrap()}pub fn last<D>(&self, snapshot: &DisplaySnapshot) -> Selection<D>@@ -361,7 +372,7 @@ impl SelectionsCollection {.next().unwrap();}- self.all_iter(snapshot).last().unwrap()+ self.all_iter(snapshot, true).last().unwrap()}/// Returns a list of (potentially backwards!) ranges representing the selections.@@ -413,6 +424,9 @@ impl SelectionsCollection {reversed: bool,text_layout_details: &TextLayoutDetails,) -> Option<Selection<Point>> {+ if display_map.is_block_line(row) {+ return None;+ }let is_empty = positions.start == positions.end;let line_len = display_map.line_len(row);let line = display_map.layout_row(row, text_layout_details);@@ -432,7 +446,7 @@ impl SelectionsCollection {};Some(Selection {- id: post_inc(&mut self.next_selection_id),+ id: self.allocate_selection_id(),start: start.to_point(display_map),end: end.to_point(display_map),reversed,@@ -443,52 +457,28 @@ impl SelectionsCollection {})}- /// Attempts to build a selection in the provided buffer row using the- /// same tab-expanded column range as specified.- /// Returns `None` if the range is not empty but it starts past the line's- /// length, meaning that the line isn't long enough to be contained within- /// part of the provided range.- fn build_columnar_selection_from_tab_expanded_columns(+ pub(crate) fn build_columnar_selections_from_tab_expanded_columns(&mut self,- display_map: &DisplaySnapshot,- multi_buffer_row: MultiBufferRow,- goal_columns: &Range<u32>,- reversed: bool,- text_layout_details: &TextLayoutDetails,- ) -> Option<Selection<Point>> {- let is_empty = goal_columns.start == goal_columns.end;- let line_len = display_map.tab_expanded_line_len(multi_buffer_row);-- let (start, end) = if is_empty {- let point =- display_map.point_for_tab_expanded_column(multi_buffer_row, goal_columns.start);- (point, point)- } else {- if goal_columns.start >= line_len {- return None;- }-- let start =- display_map.point_for_tab_expanded_column(multi_buffer_row, goal_columns.start);- let end = display_map.point_for_tab_expanded_column(multi_buffer_row, goal_columns.end);- (start, end)- };-- let start_display_point = start.to_display_point(display_map);- let end_display_point = end.to_display_point(display_map);- let start_x = display_map.x_for_display_point(start_display_point, text_layout_details);- let end_x = display_map.x_for_display_point(end_display_point, text_layout_details);-- Some(Selection {- id: post_inc(&mut self.next_selection_id),- start,- end,- reversed,- goal: SelectionGoal::HorizontalRange {- start: start_x.min(end_x).into(),- end: start_x.max(end_x).into(),- },- })+ rows: &mut ColumnarSelectionRows<'_>,+ queries: &[(u32, Range<u32>, bool)],+ ) -> Vec<Option<Selection<Point>>> {+ let row_queries = queries+ .iter()+ .map(|(row, columns, _)| (*row, columns.clone()))+ .collect::<Vec<_>>();+ rows.points_for_rows(&row_queries)+ .into_iter()+ .zip(queries)+ .map(|(points, &(_, _, reversed))| {+ points.map(|(start, end)| Selection {+ id: self.allocate_selection_id(),+ start,+ end,+ reversed,+ goal: SelectionGoal::None,+ })+ })+ .collect()}/// Finds the next columnar selection by walking display rows one at a time@@ -524,37 +514,82 @@ impl SelectionsCollection {None}- /// Finds the next columnar selection by skipping to the next buffer row,- /// ignoring soft-wrapped lines.- pub(crate) fn find_next_columnar_selection_by_buffer_row(+ pub(crate) fn find_next_columnar_selections_by_buffer_row(&mut self,display_map: &DisplaySnapshot,- start_row: DisplayRow,- end_row: DisplayRow,+ rows: &mut ColumnarSelectionRows<'_>,+ queries: &[(Selection<Point>, Range<u32>)],above: bool,- goal_columns: &Range<u32>,- reversed: bool,- text_layout_details: &TextLayoutDetails,- ) -> Option<Selection<Point>> {- let mut row = start_row;- let direction = if above { -1 } else { 1 };- while row != end_row {- let new_row =- display_map.start_of_relative_buffer_row(DisplayPoint::new(row, 0), direction);- row = new_row.row();- let buffer_row = MultiBufferRow(new_row.to_point(display_map).row);-- if let Some(selection) = self.build_columnar_selection_from_tab_expanded_columns(- display_map,- buffer_row,- goal_columns,- reversed,- text_layout_details,- ) {- return Some(selection);+ ) -> Vec<Option<Selection<Point>>> {+ let tabs = display_map.tab_snapshot();+ let max_row = tabs.max_point().row();+ let next_row = |row: u32| {+ if above {+ row.checked_sub(1)+ } else {+ row.checked_add(1).filter(|row| *row <= max_row)+ }+ };+ let mut pending = BTreeMap::<_, Vec<_>>::new();+ let mut answers = vec![None; queries.len()];+ for (index, (selection, columns)) in queries.iter().enumerate() {+ if columns.start > columns.end {+ continue;+ }+ let point = if above {+ selection.start+ } else {+ selection.end+ };+ if let Some(row) = next_row(tabs.point_to_tab_point(point, Bias::Left).row()) {+ pending.entry(row).or_default().push(index);}}- None+ while let Some((row, query_indices)) = if above {+ pending.pop_last()+ } else {+ pending.pop_first()+ } {+ if let Some(hidden_rows) = display_map.fully_replaced_tab_rows(row) {+ let row = if above {+ *hidden_rows.start()+ } else {+ *hidden_rows.end()+ };+ if let Some(row) = next_row(row) {+ pending.entry(row).or_default().extend(query_indices);+ }+ continue;+ }+ let row_queries = query_indices+ .iter()+ .map(|&index| (row, queries[index].1.clone()))+ .collect::<Vec<_>>();+ let next_row = next_row(row);+ for (index, points) in query_indices+ .into_iter()+ .zip(rows.points_for_rows(&row_queries))+ {+ if let Some(points) = points {+ answers[index] = Some(points);+ } else if let Some(row) = next_row {+ pending.entry(row).or_default().push(index);+ }+ }+ }+ answers+ .into_iter()+ .zip(queries)+ .map(|(points, (selection, _))| {+ points.map(|(start, end)| Selection {+ id: self.allocate_selection_id(),+ start,+ end,+ reversed: selection.reversed,+ goal: SelectionGoal::None,+ })+ })+ .collect()}pub fn change_with<R>(@@ -643,6 +678,12 @@ impl SelectionsCollection {pub fn set_is_extending(&mut self, is_extending: bool) {self.is_extending = is_extending;}++ fn allocate_selection_id(&mut self) -> usize {+ let id = self.next_selection_id;+ self.next_selection_id = id.wrapping_add(1);+ id+ }}pub struct MutableSelectionsCollection<'snap, 'a> {@@ -714,7 +755,7 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {.and_then(|excerpt| buffer_snapshot.anchor_in_excerpt(excerpt.context.start)).unwrap_or_else(|| self.snapshot.anchor_before(MultiBufferOffset(0)));self.collection.disjoint = Arc::from([Selection {- id: post_inc(&mut self.collection.next_selection_id),+ id: self.collection.allocate_selection_id(),start: anchor,end: anchor,reversed: false,@@ -746,7 +787,7 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {false};Selection {- id: post_inc(&mut self.collection.next_selection_id),+ id: self.collection.allocate_selection_id(),start,end,reversed,@@ -806,7 +847,7 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {false};selections.push(Selection {- id: post_inc(&mut self.collection.next_selection_id),+ id: self.collection.allocate_selection_id(),start,end,reversed,@@ -895,7 +936,7 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {false};Selection {- id: post_inc(&mut self.collection.next_selection_id),+ id: self.collection.allocate_selection_id(),start,end,reversed,@@ -923,7 +964,7 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {false};Selection {- id: post_inc(&mut self.collection.next_selection_id),+ id: self.collection.allocate_selection_id(),start,end,reversed,@@ -935,7 +976,7 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {}pub fn new_selection_id(&mut self) -> usize {- post_inc(&mut self.next_selection_id)+ self.collection.allocate_selection_id()}pub fn select_display_ranges<T>(&mut self, ranges: T)@@ -954,7 +995,7 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {false};Selection {- id: post_inc(&mut self.collection.next_selection_id),+ id: self.collection.allocate_selection_id(),start: start.to_point(self.snapshot),end: end.to_point(self.snapshot),reversed,@@ -1088,7 +1129,7 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {.map(|cursor| {let cursor_point = cursor.to_point(self.snapshot);Selection {- id: post_inc(&mut self.collection.next_selection_id),+ id: self.collection.allocate_selection_id(),start: cursor_point,end: cursor_point,reversed: false,@@ -1103,6 +1144,10 @@ impl<'snap, 'a> MutableSelectionsCollection<'snap, 'a> {self.selections_changed = true;self.pending.as_mut().map(|pending| &mut pending.selection)}++ pub(crate) fn select_anchors_unexpanded(&mut self, selections: Vec<Selection<Anchor>>) {+ self.select(selections);+ }}impl Deref for MutableSelectionsCollection<'_, '_> {@@ -1209,13 +1254,25 @@ pub(crate) fn resolve_selections_wrapping_blocks<'a, D, I>(selections: I,map: &'a DisplaySnapshot,) -> impl 'a + Iterator<Item = Selection<D>>+where+ D: MultiBufferDimension + Sub + AddAssign<<D as Sub>::Output> + Ord,+ I: 'a + IntoIterator<Item = &'a Selection<Anchor>>,+{+ resolve_selections(selections, map, true)+}++fn resolve_selections<'a, D, I>(+ selections: I,+ map: &'a DisplaySnapshot,+ expand_blocks: bool,+) -> impl 'a + Iterator<Item = Selection<D>>whereD: MultiBufferDimension + Sub + AddAssign<<D as Sub>::Output> + Ord,I: 'a + IntoIterator<Item = &'a Selection<Anchor>>,{// Without collapsed content, coalescing in buffer point space is equivalent to coalescing in// display point space, so skip the per-selection display-coordinate round trip.- if !map.has_collapsed_content() {+ if !expand_blocks || !map.has_collapsed_content() {Either::Left(resolve_selections_without_display_round_trip(selections, map,))@@ -1356,7 +1413,9 @@ mod tests {use super::*;use crate::{MultiBuffer,- display_map::{BlockPlacement, BlockProperties, BlockStyle, DisplayMap, FoldPlaceholder},+ display_map::{+ BlockPlacement, BlockProperties, BlockStyle, Crease, DisplayMap, FoldPlaceholder,+ },test::test_font,};use gpui::{AppContext as _, IntoElement as _, div, px};@@ -1366,26 +1425,7 @@ mod tests {use std::sync::Arc;fn row_range_snapshot(cx: &mut gpui::TestAppContext, text: &str) -> DisplaySnapshot {- cx.update(|cx| {- let settings = SettingsStore::test(cx);- cx.set_global(settings);- crate::init(cx);- });- let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));- let display_map = cx.new(|cx| {- DisplayMap::new(- buffer,- test_font(),- px(14.),- None,- 1,- 1,- FoldPlaceholder::test(),- DiagnosticSeverity::Warning,- cx,- )- });- display_map.update(cx, |map, cx| map.snapshot(cx))+ selection_test_display_map(cx, text).update(cx, |map, cx| map.snapshot(cx))}fn row_range_collection(@@ -1552,6 +1592,418 @@ mod tests {assert_eq!(fast_offsets, slow_offsets);}+ #[gpui::test]+ fn select_anchors_unexpanded_preserves_hidden_buffer_ranges(cx: &mut gpui::TestAppContext) {+ let map = selection_test_display_map(cx, "aaaa\nbbbb\ncccc\ndddd\neeee\nffff");+ let snapshot = map.update(cx, |map, cx| {+ map.fold(+ vec![Crease::simple(+ Point::new(1, 0)..Point::new(2, 4),+ FoldPlaceholder::test(),+ )],+ cx,+ );+ let buffer = map.snapshot(cx).buffer_snapshot().clone();+ map.insert_blocks(+ [BlockProperties {+ placement: BlockPlacement::Replace(+ buffer.anchor_after(Point::new(4, 0))+ ..=buffer.anchor_before(Point::new(5, 4)),+ ),+ height: Some(1),+ style: BlockStyle::Fixed,+ render: Arc::new(|_| div().into_any_element()),+ priority: 0,+ }],+ cx,+ );+ map.snapshot(cx)+ });+ let saved = [1, 2, 4, 5]+ .into_iter()+ .map(|row| Selection {+ id: row as usize + 10,+ start: Point::new(row, 1),+ end: Point::new(row, 2),+ reversed: row % 2 == 0,+ goal: SelectionGoal::None,+ })+ .collect::<Vec<_>>();+ let anchors = saved+ .iter()+ .map(|selection| {+ selection_to_anchor_selection(+ selection.map(|point| point.to_offset(&snapshot)),+ &snapshot,+ )+ })+ .collect::<Vec<_>>();+ let mut collection = SelectionsCollection::new();+ collection.change_with(&snapshot, |selections| {+ selections.select_anchors_unexpanded(anchors);+ });+ assert_eq!(collection.all_unexpanded::<Point>(&snapshot), saved);+ assert_eq!(collection.pending_anchor(), None);++ let mut overlapping = saved[0];+ overlapping.id = 30;+ overlapping.end.column = 3;+ collection.change_with(&snapshot, |selections| {+ selections.select_anchors_unexpanded(+ [saved[0], overlapping]+ .into_iter()+ .map(|selection| {+ selection_to_anchor_selection(+ selection.map(|point| point.to_offset(&snapshot)),+ &snapshot,+ )+ })+ .collect(),+ );+ });+ assert_eq!(+ collection.all_unexpanded::<Point>(&snapshot),+ vec![Selection {+ end: overlapping.end,+ ..saved[0]+ }]+ );+ }++ #[gpui::test]+ fn columnar_selection_batch_preserves_request_order(cx: &mut gpui::TestAppContext) {+ let snapshot = row_range_snapshot(cx, "abcd\n\né🦀z\n\txyz");+ assert_eq!(snapshot.tab_snapshot().text(), "abcd\n\né🦀z\n xyz");+ let mut rows = ColumnarSelectionRows::new(&snapshot);+ let mut collection = SelectionsCollection::new();+ let actual = collection.build_columnar_selections_from_tab_expanded_columns(+ &mut rows,+ &[+ (2, 1..2, true),+ (1, 0..1, false),+ (0, 2..u32::MAX, false),+ (2, 0..3, false),+ (u32::MAX, 0..0, true),+ (1, u32::MAX..u32::MAX, true),+ (0, 4..5, true),+ (0, u32::MAX..u32::MAX, false),+ (3, 1..3, true),+ (3, 0..5, false),+ (2, 3..4, false),+ (0, Range { start: 3, end: 2 }, false),+ ],+ );+ assert_eq!(+ actual,+ vec![+ Some(columnar_test_selection(1, 2, 2..6, true)),+ None,+ Some(columnar_test_selection(2, 0, 2..4, false)),+ Some(columnar_test_selection(3, 2, 0..7, false)),+ None,+ Some(columnar_test_selection(4, 1, 0..0, true)),+ None,+ Some(columnar_test_selection(5, 0, 4..4, false)),+ Some(columnar_test_selection(6, 3, 0..0, true)),+ Some(columnar_test_selection(7, 3, 0..2, false)),+ None,+ None,+ ]+ );+ assert_eq!(collection.next_selection_id(), 8);+ assert_eq!(+ collection.build_columnar_selections_from_tab_expanded_columns(&mut rows, &[]),+ Vec::new()+ );+ assert_eq!(collection.next_selection_id(), 8);+ }++ #[gpui::test]+ fn columnar_selection_batch_joins_different_starts_and_skips(cx: &mut gpui::TestAppContext) {+ for above in [false, true] {+ let mut lines = [+ "abcdefgh", "x", "", "abcdefgh", "x", "", "abcdefgh", "x", "abcdefgh",+ ];+ if above {+ lines.reverse();+ }+ let snapshot = row_range_snapshot(cx, &lines.join("\n"));+ let mut rows = ColumnarSelectionRows::new(&snapshot);+ let mut collection = SelectionsCollection::new();+ let row = |row| if above { 8 - row } else { row };+ let queries = [+ (5, 2..5, false),+ (0, 3..7, true),+ (2, 2..4, false),+ (1, 1..2, true),+ (8, 0..1, false),+ (0, 8..9, true),+ (3, 0..0, false),+ (6, 0..2, true),+ (6, u32::MAX..u32::MAX, false),+ (5, Range { start: 1, end: 0 }, true),+ (7, 0..8, true),+ ]+ .into_iter()+ .enumerate()+ .map(|(index, (source_row, columns, reversed))| {+ (+ columnar_test_selection(index + 20, row(source_row), 0..0, reversed),+ columns,+ )+ })+ .collect::<Vec<_>>();+ assert_eq!(+ collection.find_next_columnar_selections_by_buffer_row(+ &snapshot, &mut rows, &queries, above,+ ),+ vec![+ Some(columnar_test_selection(1, row(6), 2..5, false)),+ Some(columnar_test_selection(2, row(3), 3..7, true)),+ Some(columnar_test_selection(3, row(3), 2..4, false)),+ Some(columnar_test_selection(4, row(3), 1..2, true)),+ None,+ None,+ Some(columnar_test_selection(5, row(4), 0..0, false)),+ Some(columnar_test_selection(6, row(7), 0..1, true)),+ Some(columnar_test_selection(7, row(7), 1..1, false)),+ None,+ Some(columnar_test_selection(8, row(8), 0..8, true)),+ ],+ "above: {above}"+ );+ assert_eq!(collection.next_selection_id(), 9);+ }+ }++ #[gpui::test]+ fn columnar_selection_batch_uses_directional_endpoints(cx: &mut gpui::TestAppContext) {+ let snapshot = row_range_snapshot(cx, "abcd\nabcd\nabcd\nabcd\nabcd");+ let mut rows = ColumnarSelectionRows::new(&snapshot);+ for above in [false, true] {+ let mut collection = SelectionsCollection::new();+ let queries = [false, true].map(|reversed| {+ (+ Selection {+ id: 20,+ start: Point::new(1, 1),+ end: Point::new(3, 2),+ reversed,+ goal: SelectionGoal::None,+ },+ 1..3,+ )+ });+ let destination = if above { 0 } else { 4 };+ assert_eq!(+ collection.find_next_columnar_selections_by_buffer_row(+ &snapshot, &mut rows, &queries, above,+ ),+ vec![+ Some(columnar_test_selection(1, destination, 1..3, false)),+ Some(columnar_test_selection(2, destination, 1..3, true)),+ ]+ );+ assert_eq!(collection.next_selection_id(), 3);+ }+ }++ #[gpui::test]+ fn columnar_selection_batch_unavailable_does_not_allocate(cx: &mut gpui::TestAppContext) {+ for text in ["", "abcd"] {+ let snapshot = row_range_snapshot(cx, text);+ let mut rows = ColumnarSelectionRows::new(&snapshot);+ let mut collection = SelectionsCollection::new();+ for above in [false, true] {+ let queries = [+ (columnar_test_selection(0, 0, 0..0, false), 0..0),+ (columnar_test_selection(0, 0, 0..0, true), 0..1),+ ];+ assert_eq!(+ collection.find_next_columnar_selections_by_buffer_row(+ &snapshot, &mut rows, &queries, above,+ ),+ vec![None, None]+ );+ assert_eq!(+ collection.find_next_columnar_selections_by_buffer_row(+ &snapshot,+ &mut rows,+ &[],+ above,+ ),+ Vec::new()+ );+ assert_eq!(collection.next_selection_id(), 1);+ }+ }+ }++ #[gpui::test]+ fn columnar_selection_batch_joins_replacement_skips(cx: &mut gpui::TestAppContext) {+ let map = selection_test_display_map(+ cx,+ &iter::repeat_n("abcdefgh", 9).collect::<Vec<_>>().join("\n"),+ );+ let snapshot = map.update(cx, |map, cx| {+ let buffer = map.snapshot(cx).buffer_snapshot().clone();+ map.insert_blocks(+ [BlockProperties {+ placement: BlockPlacement::Replace(+ buffer.anchor_after(Point::new(3, 0))+ ..=buffer.anchor_before(Point::new(5, 8)),+ ),+ height: Some(1),+ style: BlockStyle::Fixed,+ render: Arc::new(|_| div().into_any_element()),+ priority: 0,+ }],+ cx,+ );+ map.snapshot(cx)+ });+ for above in [false, true] {+ let mut rows = ColumnarSelectionRows::new(&snapshot);+ let mut collection = SelectionsCollection::new();+ let row = |row| if above { 8 - row } else { row };+ let queries = [+ (6, 1..3, false),+ (0, 2..6, true),+ (2, 1..2, false),+ (4, 0..0, true),+ (5, 3..7, true),+ (8, 0..0, false),+ (1, 8..9, false),+ ]+ .into_iter()+ .enumerate()+ .map(|(index, (source_row, columns, reversed))| {+ (+ columnar_test_selection(index + 20, row(source_row), 0..0, reversed),+ columns,+ )+ })+ .collect::<Vec<_>>();+ assert_eq!(+ collection.find_next_columnar_selections_by_buffer_row(+ &snapshot, &mut rows, &queries, above,+ ),+ vec![+ Some(columnar_test_selection(1, row(7), 1..3, false)),+ Some(columnar_test_selection(2, row(1), 2..6, true)),+ Some(columnar_test_selection(3, row(6), 1..2, false)),+ Some(columnar_test_selection(4, row(6), 0..0, true)),+ Some(columnar_test_selection(5, row(6), 3..7, true)),+ None,+ None,+ ],+ "above: {above}"+ );+ assert_eq!(collection.next_selection_id(), 6);+ }+ }++ #[gpui::test]+ fn columnar_selection_skips_replacement_input_rows(cx: &mut gpui::TestAppContext) {+ let text = iter::repeat_n("abcd", 1002).collect::<Vec<_>>().join("\n");+ for hidden in [1..=1000, 0..=1000, 1..=1001, 0..=1001] {+ let map = selection_test_display_map(cx, &text);+ let snapshot = map.update(cx, |map, cx| {+ let buffer = map.snapshot(cx).buffer_snapshot().clone();+ map.insert_blocks(+ [BlockProperties {+ placement: BlockPlacement::Replace(+ buffer.anchor_after(Point::new(*hidden.start(), 0))+ ..=buffer.anchor_before(Point::new(*hidden.end(), 4)),+ ),+ height: Some(1),+ style: BlockStyle::Fixed,+ render: Arc::new(|_| div().into_any_element()),+ priority: 0,+ }],+ cx,+ );+ map.snapshot(cx)+ });+ for above in [false, true] {+ let source_row = if above { 1001 } else { 0 };+ let source = Selection {+ id: 0,+ start: Point::new(source_row, 0),+ end: Point::new(source_row, 1),+ reversed: above,+ goal: SelectionGoal::None,+ };+ let expected_row = if above {+ hidden.start().checked_sub(1)+ } else if *hidden.end() == 1001 {+ None+ } else {+ Some(hidden.end() + 1)+ };+ let mut collection = SelectionsCollection::new();+ let mut rows = ColumnarSelectionRows::new(&snapshot);+ let actual = collection.find_next_columnar_selections_by_buffer_row(+ &snapshot,+ &mut rows,+ &[(source, 0..1)],+ above,+ );+ assert_eq!(+ actual,+ vec![expected_row.map(|row| Selection {+ id: 1,+ start: Point::new(row, 0),+ end: Point::new(row, 1),+ reversed: above,+ goal: SelectionGoal::None,+ })],+ "hidden: {hidden:?}, above: {above}"+ );+ }+ }+ }++ fn columnar_test_selection(+ id: usize,+ row: u32,+ columns: Range<u32>,+ reversed: bool,+ ) -> Selection<Point> {+ Selection {+ id,+ start: Point::new(row, columns.start),+ end: Point::new(row, columns.end),+ reversed,+ goal: SelectionGoal::None,+ }+ }++ fn selection_test_display_map(+ cx: &mut gpui::TestAppContext,+ text: &str,+ ) -> gpui::Entity<DisplayMap> {+ cx.update(|cx| {+ let settings = SettingsStore::test(cx);+ cx.set_global(settings);+ crate::init(cx);+ });+ let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));+ cx.new(|cx| {+ DisplayMap::new(+ buffer,+ test_font(),+ px(14.),+ None,+ 1,+ 1,+ FoldPlaceholder::test(),+ DiagnosticSeverity::Warning,+ cx,+ )+ })+ }+fn random_text(rng: &mut StdRng) -> String {let mut text = String::new();for line in 0..rng.random_range(8..32) {