1use crate::{ChunkRenderer, HighlightStyles, InlayId};
2use collections::BTreeSet;
3use gpui::{Hsla, Rgba};
4use language::{Chunk, Edit, Point, TextSummary};
5use multi_buffer::{
6 Anchor, MultiBufferRow, MultiBufferRows, MultiBufferSnapshot, RowInfo, ToOffset,
7};
8use std::{
9 cmp,
10 ops::{Add, AddAssign, Range, Sub, SubAssign},
11 sync::Arc,
12};
13use sum_tree::{Bias, Cursor, Dimensions, SumTree};
14use text::{Patch, Rope};
15use ui::{ActiveTheme, IntoElement as _, ParentElement as _, Styled as _, div};
16
17use super::{Highlights, custom_highlights::CustomHighlightsChunks, fold_map::ChunkRendererId};
18
19/// Decides where the [`Inlay`]s should be displayed.
20///
21/// See the [`display_map` module documentation](crate::display_map) for more information.
22pub struct InlayMap {
23 snapshot: InlaySnapshot,
24 inlays: Vec<Inlay>,
25}
26
27#[derive(Clone)]
28pub struct InlaySnapshot {
29 pub buffer: MultiBufferSnapshot,
30 transforms: SumTree<Transform>,
31 pub version: usize,
32}
33
34#[derive(Clone, Debug)]
35enum Transform {
36 Isomorphic(TextSummary),
37 Inlay(Inlay),
38}
39
40#[derive(Debug, Clone)]
41pub struct Inlay {
42 pub id: InlayId,
43 pub position: Anchor,
44 pub text: text::Rope,
45 color: Option<Hsla>,
46}
47
48impl Inlay {
49 pub fn hint(id: usize, position: Anchor, hint: &project::InlayHint) -> Self {
50 let mut text = hint.text();
51 if hint.padding_right && text.reversed_chars_at(text.len()).next() != Some(' ') {
52 text.push(" ");
53 }
54 if hint.padding_left && text.chars_at(0).next() != Some(' ') {
55 text.push_front(" ");
56 }
57 Self {
58 id: InlayId::Hint(id),
59 position,
60 text,
61 color: None,
62 }
63 }
64
65 #[cfg(any(test, feature = "test-support"))]
66 pub fn mock_hint(id: usize, position: Anchor, text: impl Into<Rope>) -> Self {
67 Self {
68 id: InlayId::Hint(id),
69 position,
70 text: text.into(),
71 color: None,
72 }
73 }
74
75 pub fn color(id: usize, position: Anchor, color: Rgba) -> Self {
76 Self {
77 id: InlayId::Color(id),
78 position,
79 text: Rope::from("◼"),
80 color: Some(Hsla::from(color)),
81 }
82 }
83
84 pub fn edit_prediction<T: Into<Rope>>(id: usize, position: Anchor, text: T) -> Self {
85 Self {
86 id: InlayId::EditPrediction(id),
87 position,
88 text: text.into(),
89 color: None,
90 }
91 }
92
93 pub fn debugger<T: Into<Rope>>(id: usize, position: Anchor, text: T) -> Self {
94 Self {
95 id: InlayId::DebuggerValue(id),
96 position,
97 text: text.into(),
98 color: None,
99 }
100 }
101
102 #[cfg(any(test, feature = "test-support"))]
103 pub fn get_color(&self) -> Option<Hsla> {
104 self.color
105 }
106}
107
108impl sum_tree::Item for Transform {
109 type Summary = TransformSummary;
110
111 fn summary(&self, _: &()) -> Self::Summary {
112 match self {
113 Transform::Isomorphic(summary) => TransformSummary {
114 input: *summary,
115 output: *summary,
116 },
117 Transform::Inlay(inlay) => TransformSummary {
118 input: TextSummary::default(),
119 output: inlay.text.summary(),
120 },
121 }
122 }
123}
124
125#[derive(Clone, Debug, Default)]
126struct TransformSummary {
127 input: TextSummary,
128 output: TextSummary,
129}
130
131impl sum_tree::Summary for TransformSummary {
132 type Context = ();
133
134 fn zero(_cx: &()) -> Self {
135 Default::default()
136 }
137
138 fn add_summary(&mut self, other: &Self, _: &()) {
139 self.input += &other.input;
140 self.output += &other.output;
141 }
142}
143
144pub type InlayEdit = Edit<InlayOffset>;
145
146#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
147pub struct InlayOffset(pub usize);
148
149impl Add for InlayOffset {
150 type Output = Self;
151
152 fn add(self, rhs: Self) -> Self::Output {
153 Self(self.0 + rhs.0)
154 }
155}
156
157impl Sub for InlayOffset {
158 type Output = Self;
159
160 fn sub(self, rhs: Self) -> Self::Output {
161 Self(self.0 - rhs.0)
162 }
163}
164
165impl AddAssign for InlayOffset {
166 fn add_assign(&mut self, rhs: Self) {
167 self.0 += rhs.0;
168 }
169}
170
171impl SubAssign for InlayOffset {
172 fn sub_assign(&mut self, rhs: Self) {
173 self.0 -= rhs.0;
174 }
175}
176
177impl<'a> sum_tree::Dimension<'a, TransformSummary> for InlayOffset {
178 fn zero(_cx: &()) -> Self {
179 Default::default()
180 }
181
182 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
183 self.0 += &summary.output.len;
184 }
185}
186
187#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
188pub struct InlayPoint(pub Point);
189
190impl Add for InlayPoint {
191 type Output = Self;
192
193 fn add(self, rhs: Self) -> Self::Output {
194 Self(self.0 + rhs.0)
195 }
196}
197
198impl Sub for InlayPoint {
199 type Output = Self;
200
201 fn sub(self, rhs: Self) -> Self::Output {
202 Self(self.0 - rhs.0)
203 }
204}
205
206impl<'a> sum_tree::Dimension<'a, TransformSummary> for InlayPoint {
207 fn zero(_cx: &()) -> Self {
208 Default::default()
209 }
210
211 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
212 self.0 += &summary.output.lines;
213 }
214}
215
216impl<'a> sum_tree::Dimension<'a, TransformSummary> for usize {
217 fn zero(_cx: &()) -> Self {
218 Default::default()
219 }
220
221 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
222 *self += &summary.input.len;
223 }
224}
225
226impl<'a> sum_tree::Dimension<'a, TransformSummary> for Point {
227 fn zero(_cx: &()) -> Self {
228 Default::default()
229 }
230
231 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
232 *self += &summary.input.lines;
233 }
234}
235
236#[derive(Clone)]
237pub struct InlayBufferRows<'a> {
238 transforms: Cursor<'a, Transform, Dimensions<InlayPoint, Point>>,
239 buffer_rows: MultiBufferRows<'a>,
240 inlay_row: u32,
241 max_buffer_row: MultiBufferRow,
242}
243
244pub struct InlayChunks<'a> {
245 transforms: Cursor<'a, Transform, Dimensions<InlayOffset, usize>>,
246 buffer_chunks: CustomHighlightsChunks<'a>,
247 buffer_chunk: Option<Chunk<'a>>,
248 inlay_chunks: Option<text::Chunks<'a>>,
249 inlay_chunk: Option<&'a str>,
250 output_offset: InlayOffset,
251 max_output_offset: InlayOffset,
252 highlight_styles: HighlightStyles,
253 highlights: Highlights<'a>,
254 snapshot: &'a InlaySnapshot,
255}
256
257#[derive(Clone)]
258pub struct InlayChunk<'a> {
259 pub chunk: Chunk<'a>,
260 /// Whether the inlay should be customly rendered.
261 pub renderer: Option<ChunkRenderer>,
262}
263
264impl InlayChunks<'_> {
265 pub fn seek(&mut self, new_range: Range<InlayOffset>) {
266 self.transforms.seek(&new_range.start, Bias::Right);
267
268 let buffer_range = self.snapshot.to_buffer_offset(new_range.start)
269 ..self.snapshot.to_buffer_offset(new_range.end);
270 self.buffer_chunks.seek(buffer_range);
271 self.inlay_chunks = None;
272 self.buffer_chunk = None;
273 self.output_offset = new_range.start;
274 self.max_output_offset = new_range.end;
275 }
276
277 pub fn offset(&self) -> InlayOffset {
278 self.output_offset
279 }
280}
281
282impl<'a> Iterator for InlayChunks<'a> {
283 type Item = InlayChunk<'a>;
284
285 fn next(&mut self) -> Option<Self::Item> {
286 if self.output_offset == self.max_output_offset {
287 return None;
288 }
289
290 let chunk = match self.transforms.item()? {
291 Transform::Isomorphic(_) => {
292 let chunk = self
293 .buffer_chunk
294 .get_or_insert_with(|| self.buffer_chunks.next().unwrap());
295 if chunk.text.is_empty() {
296 *chunk = self.buffer_chunks.next().unwrap();
297 }
298
299 let desired_bytes = self.transforms.end().0.0 - self.output_offset.0;
300
301 // If we're already at the transform boundary, skip to the next transform
302 if desired_bytes == 0 {
303 self.inlay_chunks = None;
304 self.transforms.next();
305 return self.next();
306 }
307
308 // Determine split index handling edge cases
309 let split_index = if desired_bytes >= chunk.text.len() {
310 chunk.text.len()
311 } else if chunk.text.is_char_boundary(desired_bytes) {
312 desired_bytes
313 } else {
314 find_next_utf8_boundary(chunk.text, desired_bytes)
315 };
316
317 let (prefix, suffix) = chunk.text.split_at(split_index);
318
319 chunk.text = suffix;
320 self.output_offset.0 += prefix.len();
321 InlayChunk {
322 chunk: Chunk {
323 text: prefix,
324 ..chunk.clone()
325 },
326 renderer: None,
327 }
328 }
329 Transform::Inlay(inlay) => {
330 let mut inlay_style_and_highlight = None;
331 if let Some(inlay_highlights) = self.highlights.inlay_highlights {
332 for (_, inlay_id_to_data) in inlay_highlights.iter() {
333 let style_and_highlight = inlay_id_to_data.get(&inlay.id);
334 if style_and_highlight.is_some() {
335 inlay_style_and_highlight = style_and_highlight;
336 break;
337 }
338 }
339 }
340
341 let mut renderer = None;
342 let mut highlight_style = match inlay.id {
343 InlayId::EditPrediction(_) => self.highlight_styles.edit_prediction.map(|s| {
344 if inlay.text.chars().all(|c| c.is_whitespace()) {
345 s.whitespace
346 } else {
347 s.insertion
348 }
349 }),
350 InlayId::Hint(_) => self.highlight_styles.inlay_hint,
351 InlayId::DebuggerValue(_) => self.highlight_styles.inlay_hint,
352 InlayId::Color(_) => {
353 if let Some(color) = inlay.color {
354 renderer = Some(ChunkRenderer {
355 id: ChunkRendererId::Inlay(inlay.id),
356 render: Arc::new(move |cx| {
357 div()
358 .relative()
359 .size_3p5()
360 .child(
361 div()
362 .absolute()
363 .right_1()
364 .size_3()
365 .border_1()
366 .border_color(cx.theme().colors().border)
367 .bg(color),
368 )
369 .into_any_element()
370 }),
371 constrain_width: false,
372 measured_width: None,
373 });
374 }
375 self.highlight_styles.inlay_hint
376 }
377 };
378 let next_inlay_highlight_endpoint;
379 let offset_in_inlay = self.output_offset - self.transforms.start().0;
380 if let Some((style, highlight)) = inlay_style_and_highlight {
381 let range = &highlight.range;
382 if offset_in_inlay.0 < range.start {
383 next_inlay_highlight_endpoint = range.start - offset_in_inlay.0;
384 } else if offset_in_inlay.0 >= range.end {
385 next_inlay_highlight_endpoint = usize::MAX;
386 } else {
387 next_inlay_highlight_endpoint = range.end - offset_in_inlay.0;
388 highlight_style
389 .get_or_insert_with(Default::default)
390 .highlight(*style);
391 }
392 } else {
393 next_inlay_highlight_endpoint = usize::MAX;
394 }
395
396 let inlay_chunks = self.inlay_chunks.get_or_insert_with(|| {
397 let start = offset_in_inlay;
398 let end = cmp::min(self.max_output_offset, self.transforms.end().0)
399 - self.transforms.start().0;
400 inlay.text.chunks_in_range(start.0..end.0)
401 });
402 let inlay_chunk = self
403 .inlay_chunk
404 .get_or_insert_with(|| inlay_chunks.next().unwrap());
405
406 // Determine split index handling edge cases
407 let split_index = if next_inlay_highlight_endpoint >= inlay_chunk.len() {
408 inlay_chunk.len()
409 } else if next_inlay_highlight_endpoint == 0 {
410 // Need to take at least one character to make progress
411 inlay_chunk
412 .chars()
413 .next()
414 .map(|c| c.len_utf8())
415 .unwrap_or(1)
416 } else if inlay_chunk.is_char_boundary(next_inlay_highlight_endpoint) {
417 next_inlay_highlight_endpoint
418 } else {
419 find_next_utf8_boundary(inlay_chunk, next_inlay_highlight_endpoint)
420 };
421
422 let (chunk, remainder) = inlay_chunk.split_at(split_index);
423 *inlay_chunk = remainder;
424 if inlay_chunk.is_empty() {
425 self.inlay_chunk = None;
426 }
427
428 self.output_offset.0 += chunk.len();
429
430 InlayChunk {
431 chunk: Chunk {
432 text: chunk,
433 highlight_style,
434 is_inlay: true,
435 ..Chunk::default()
436 },
437 renderer,
438 }
439 }
440 };
441
442 if self.output_offset >= self.transforms.end().0 {
443 self.inlay_chunks = None;
444 self.transforms.next();
445 }
446
447 Some(chunk)
448 }
449}
450
451impl InlayBufferRows<'_> {
452 pub fn seek(&mut self, row: u32) {
453 let inlay_point = InlayPoint::new(row, 0);
454 self.transforms.seek(&inlay_point, Bias::Left);
455
456 let mut buffer_point = self.transforms.start().1;
457 let buffer_row = MultiBufferRow(if row == 0 {
458 0
459 } else {
460 match self.transforms.item() {
461 Some(Transform::Isomorphic(_)) => {
462 buffer_point += inlay_point.0 - self.transforms.start().0.0;
463 buffer_point.row
464 }
465 _ => cmp::min(buffer_point.row + 1, self.max_buffer_row.0),
466 }
467 });
468 self.inlay_row = inlay_point.row();
469 self.buffer_rows.seek(buffer_row);
470 }
471}
472
473impl Iterator for InlayBufferRows<'_> {
474 type Item = RowInfo;
475
476 fn next(&mut self) -> Option<Self::Item> {
477 let buffer_row = if self.inlay_row == 0 {
478 self.buffer_rows.next().unwrap()
479 } else {
480 match self.transforms.item()? {
481 Transform::Inlay(_) => Default::default(),
482 Transform::Isomorphic(_) => self.buffer_rows.next().unwrap(),
483 }
484 };
485
486 self.inlay_row += 1;
487 self.transforms
488 .seek_forward(&InlayPoint::new(self.inlay_row, 0), Bias::Left);
489
490 Some(buffer_row)
491 }
492}
493
494impl InlayPoint {
495 pub fn new(row: u32, column: u32) -> Self {
496 Self(Point::new(row, column))
497 }
498
499 pub fn row(self) -> u32 {
500 self.0.row
501 }
502}
503
504impl InlayMap {
505 pub fn new(buffer: MultiBufferSnapshot) -> (Self, InlaySnapshot) {
506 let version = 0;
507 let snapshot = InlaySnapshot {
508 buffer: buffer.clone(),
509 transforms: SumTree::from_iter(Some(Transform::Isomorphic(buffer.text_summary())), &()),
510 version,
511 };
512
513 (
514 Self {
515 snapshot: snapshot.clone(),
516 inlays: Vec::new(),
517 },
518 snapshot,
519 )
520 }
521
522 pub fn sync(
523 &mut self,
524 buffer_snapshot: MultiBufferSnapshot,
525 mut buffer_edits: Vec<text::Edit<usize>>,
526 ) -> (InlaySnapshot, Vec<InlayEdit>) {
527 let snapshot = &mut self.snapshot;
528
529 if buffer_edits.is_empty()
530 && snapshot.buffer.trailing_excerpt_update_count()
531 != buffer_snapshot.trailing_excerpt_update_count()
532 {
533 buffer_edits.push(Edit {
534 old: snapshot.buffer.len()..snapshot.buffer.len(),
535 new: buffer_snapshot.len()..buffer_snapshot.len(),
536 });
537 }
538
539 if buffer_edits.is_empty() {
540 if snapshot.buffer.edit_count() != buffer_snapshot.edit_count()
541 || snapshot.buffer.non_text_state_update_count()
542 != buffer_snapshot.non_text_state_update_count()
543 || snapshot.buffer.trailing_excerpt_update_count()
544 != buffer_snapshot.trailing_excerpt_update_count()
545 {
546 snapshot.version += 1;
547 }
548
549 snapshot.buffer = buffer_snapshot;
550 (snapshot.clone(), Vec::new())
551 } else {
552 let mut inlay_edits = Patch::default();
553 let mut new_transforms = SumTree::default();
554 let mut cursor = snapshot
555 .transforms
556 .cursor::<Dimensions<usize, InlayOffset>>(&());
557 let mut buffer_edits_iter = buffer_edits.iter().peekable();
558 while let Some(buffer_edit) = buffer_edits_iter.next() {
559 new_transforms.append(cursor.slice(&buffer_edit.old.start, Bias::Left), &());
560 if let Some(Transform::Isomorphic(transform)) = cursor.item()
561 && cursor.end().0 == buffer_edit.old.start
562 {
563 push_isomorphic(&mut new_transforms, *transform);
564 cursor.next();
565 }
566
567 // Remove all the inlays and transforms contained by the edit.
568 let old_start =
569 cursor.start().1 + InlayOffset(buffer_edit.old.start - cursor.start().0);
570 cursor.seek(&buffer_edit.old.end, Bias::Right);
571 let old_end =
572 cursor.start().1 + InlayOffset(buffer_edit.old.end - cursor.start().0);
573
574 // Push the unchanged prefix.
575 let prefix_start = new_transforms.summary().input.len;
576 let prefix_end = buffer_edit.new.start;
577 push_isomorphic(
578 &mut new_transforms,
579 buffer_snapshot.text_summary_for_range(prefix_start..prefix_end),
580 );
581 let new_start = InlayOffset(new_transforms.summary().output.len);
582
583 let start_ix = match self.inlays.binary_search_by(|probe| {
584 probe
585 .position
586 .to_offset(&buffer_snapshot)
587 .cmp(&buffer_edit.new.start)
588 .then(std::cmp::Ordering::Greater)
589 }) {
590 Ok(ix) | Err(ix) => ix,
591 };
592
593 for inlay in &self.inlays[start_ix..] {
594 if !inlay.position.is_valid(&buffer_snapshot) {
595 continue;
596 }
597 let buffer_offset = inlay.position.to_offset(&buffer_snapshot);
598 if buffer_offset > buffer_edit.new.end {
599 break;
600 }
601
602 let prefix_start = new_transforms.summary().input.len;
603 let prefix_end = buffer_offset;
604 push_isomorphic(
605 &mut new_transforms,
606 buffer_snapshot.text_summary_for_range(prefix_start..prefix_end),
607 );
608
609 new_transforms.push(Transform::Inlay(inlay.clone()), &());
610 }
611
612 // Apply the rest of the edit.
613 let transform_start = new_transforms.summary().input.len;
614 push_isomorphic(
615 &mut new_transforms,
616 buffer_snapshot.text_summary_for_range(transform_start..buffer_edit.new.end),
617 );
618 let new_end = InlayOffset(new_transforms.summary().output.len);
619 inlay_edits.push(Edit {
620 old: old_start..old_end,
621 new: new_start..new_end,
622 });
623
624 // If the next edit doesn't intersect the current isomorphic transform, then
625 // we can push its remainder.
626 if buffer_edits_iter
627 .peek()
628 .is_none_or(|edit| edit.old.start >= cursor.end().0)
629 {
630 let transform_start = new_transforms.summary().input.len;
631 let transform_end =
632 buffer_edit.new.end + (cursor.end().0 - buffer_edit.old.end);
633 push_isomorphic(
634 &mut new_transforms,
635 buffer_snapshot.text_summary_for_range(transform_start..transform_end),
636 );
637 cursor.next();
638 }
639 }
640
641 new_transforms.append(cursor.suffix(), &());
642 if new_transforms.is_empty() {
643 new_transforms.push(Transform::Isomorphic(Default::default()), &());
644 }
645
646 drop(cursor);
647 snapshot.transforms = new_transforms;
648 snapshot.version += 1;
649 snapshot.buffer = buffer_snapshot;
650 snapshot.check_invariants();
651
652 (snapshot.clone(), inlay_edits.into_inner())
653 }
654 }
655
656 pub fn splice(
657 &mut self,
658 to_remove: &[InlayId],
659 to_insert: Vec<Inlay>,
660 ) -> (InlaySnapshot, Vec<InlayEdit>) {
661 let snapshot = &mut self.snapshot;
662 let mut edits = BTreeSet::new();
663
664 self.inlays.retain(|inlay| {
665 let retain = !to_remove.contains(&inlay.id);
666 if !retain {
667 let offset = inlay.position.to_offset(&snapshot.buffer);
668 edits.insert(offset);
669 }
670 retain
671 });
672
673 for inlay_to_insert in to_insert {
674 // Avoid inserting empty inlays.
675 if inlay_to_insert.text.is_empty() {
676 continue;
677 }
678
679 let offset = inlay_to_insert.position.to_offset(&snapshot.buffer);
680 match self.inlays.binary_search_by(|probe| {
681 probe
682 .position
683 .cmp(&inlay_to_insert.position, &snapshot.buffer)
684 .then(std::cmp::Ordering::Less)
685 }) {
686 Ok(ix) | Err(ix) => {
687 self.inlays.insert(ix, inlay_to_insert);
688 }
689 }
690
691 edits.insert(offset);
692 }
693
694 let buffer_edits = edits
695 .into_iter()
696 .map(|offset| Edit {
697 old: offset..offset,
698 new: offset..offset,
699 })
700 .collect();
701 let buffer_snapshot = snapshot.buffer.clone();
702 let (snapshot, edits) = self.sync(buffer_snapshot, buffer_edits);
703 (snapshot, edits)
704 }
705
706 pub fn current_inlays(&self) -> impl Iterator<Item = &Inlay> {
707 self.inlays.iter()
708 }
709
710 #[cfg(test)]
711 pub(crate) fn randomly_mutate(
712 &mut self,
713 next_inlay_id: &mut usize,
714 rng: &mut rand::rngs::StdRng,
715 ) -> (InlaySnapshot, Vec<InlayEdit>) {
716 use rand::prelude::*;
717 use util::post_inc;
718
719 let mut to_remove = Vec::new();
720 let mut to_insert = Vec::new();
721 let snapshot = &mut self.snapshot;
722 for i in 0..rng.gen_range(1..=5) {
723 if self.inlays.is_empty() || rng.r#gen() {
724 let position = snapshot.buffer.random_byte_range(0, rng).start;
725 let bias = if rng.r#gen() { Bias::Left } else { Bias::Right };
726 let len = if rng.gen_bool(0.01) {
727 0
728 } else {
729 rng.gen_range(1..=5)
730 };
731 let text = util::RandomCharIter::new(&mut *rng)
732 .filter(|ch| *ch != '\r')
733 .take(len)
734 .collect::<String>();
735
736 let next_inlay = if i % 2 == 0 {
737 Inlay::mock_hint(
738 post_inc(next_inlay_id),
739 snapshot.buffer.anchor_at(position, bias),
740 &text,
741 )
742 } else {
743 Inlay::edit_prediction(
744 post_inc(next_inlay_id),
745 snapshot.buffer.anchor_at(position, bias),
746 &text,
747 )
748 };
749 let inlay_id = next_inlay.id;
750 log::info!(
751 "creating inlay {inlay_id:?} at buffer offset {position} with bias {bias:?} and text {text:?}"
752 );
753 to_insert.push(next_inlay);
754 } else {
755 to_remove.push(
756 self.inlays
757 .iter()
758 .choose(rng)
759 .map(|inlay| inlay.id)
760 .unwrap(),
761 );
762 }
763 }
764 log::info!("removing inlays: {:?}", to_remove);
765
766 let (snapshot, edits) = self.splice(&to_remove, to_insert);
767 (snapshot, edits)
768 }
769}
770
771impl InlaySnapshot {
772 pub fn to_point(&self, offset: InlayOffset) -> InlayPoint {
773 let mut cursor = self
774 .transforms
775 .cursor::<Dimensions<InlayOffset, InlayPoint, usize>>(&());
776 cursor.seek(&offset, Bias::Right);
777 let overshoot = offset.0 - cursor.start().0.0;
778 match cursor.item() {
779 Some(Transform::Isomorphic(_)) => {
780 let buffer_offset_start = cursor.start().2;
781 let buffer_offset_end = buffer_offset_start + overshoot;
782 let buffer_start = self.buffer.offset_to_point(buffer_offset_start);
783 let buffer_end = self.buffer.offset_to_point(buffer_offset_end);
784 InlayPoint(cursor.start().1.0 + (buffer_end - buffer_start))
785 }
786 Some(Transform::Inlay(inlay)) => {
787 let overshoot = inlay.text.offset_to_point(overshoot);
788 InlayPoint(cursor.start().1.0 + overshoot)
789 }
790 None => self.max_point(),
791 }
792 }
793
794 pub fn len(&self) -> InlayOffset {
795 InlayOffset(self.transforms.summary().output.len)
796 }
797
798 pub fn max_point(&self) -> InlayPoint {
799 InlayPoint(self.transforms.summary().output.lines)
800 }
801
802 pub fn to_offset(&self, point: InlayPoint) -> InlayOffset {
803 let mut cursor = self
804 .transforms
805 .cursor::<Dimensions<InlayPoint, InlayOffset, Point>>(&());
806 cursor.seek(&point, Bias::Right);
807 let overshoot = point.0 - cursor.start().0.0;
808 match cursor.item() {
809 Some(Transform::Isomorphic(_)) => {
810 let buffer_point_start = cursor.start().2;
811 let buffer_point_end = buffer_point_start + overshoot;
812 let buffer_offset_start = self.buffer.point_to_offset(buffer_point_start);
813 let buffer_offset_end = self.buffer.point_to_offset(buffer_point_end);
814 InlayOffset(cursor.start().1.0 + (buffer_offset_end - buffer_offset_start))
815 }
816 Some(Transform::Inlay(inlay)) => {
817 let overshoot = inlay.text.point_to_offset(overshoot);
818 InlayOffset(cursor.start().1.0 + overshoot)
819 }
820 None => self.len(),
821 }
822 }
823 pub fn to_buffer_point(&self, point: InlayPoint) -> Point {
824 let mut cursor = self.transforms.cursor::<Dimensions<InlayPoint, Point>>(&());
825 cursor.seek(&point, Bias::Right);
826 match cursor.item() {
827 Some(Transform::Isomorphic(_)) => {
828 let overshoot = point.0 - cursor.start().0.0;
829 cursor.start().1 + overshoot
830 }
831 Some(Transform::Inlay(_)) => cursor.start().1,
832 None => self.buffer.max_point(),
833 }
834 }
835 pub fn to_buffer_offset(&self, offset: InlayOffset) -> usize {
836 let mut cursor = self
837 .transforms
838 .cursor::<Dimensions<InlayOffset, usize>>(&());
839 cursor.seek(&offset, Bias::Right);
840 match cursor.item() {
841 Some(Transform::Isomorphic(_)) => {
842 let overshoot = offset - cursor.start().0;
843 cursor.start().1 + overshoot.0
844 }
845 Some(Transform::Inlay(_)) => cursor.start().1,
846 None => self.buffer.len(),
847 }
848 }
849
850 pub fn to_inlay_offset(&self, offset: usize) -> InlayOffset {
851 let mut cursor = self
852 .transforms
853 .cursor::<Dimensions<usize, InlayOffset>>(&());
854 cursor.seek(&offset, Bias::Left);
855 loop {
856 match cursor.item() {
857 Some(Transform::Isomorphic(_)) => {
858 if offset == cursor.end().0 {
859 while let Some(Transform::Inlay(inlay)) = cursor.next_item() {
860 if inlay.position.bias() == Bias::Right {
861 break;
862 } else {
863 cursor.next();
864 }
865 }
866 return cursor.end().1;
867 } else {
868 let overshoot = offset - cursor.start().0;
869 return InlayOffset(cursor.start().1.0 + overshoot);
870 }
871 }
872 Some(Transform::Inlay(inlay)) => {
873 if inlay.position.bias() == Bias::Left {
874 cursor.next();
875 } else {
876 return cursor.start().1;
877 }
878 }
879 None => {
880 return self.len();
881 }
882 }
883 }
884 }
885 pub fn to_inlay_point(&self, point: Point) -> InlayPoint {
886 let mut cursor = self.transforms.cursor::<Dimensions<Point, InlayPoint>>(&());
887 cursor.seek(&point, Bias::Left);
888 loop {
889 match cursor.item() {
890 Some(Transform::Isomorphic(_)) => {
891 if point == cursor.end().0 {
892 while let Some(Transform::Inlay(inlay)) = cursor.next_item() {
893 if inlay.position.bias() == Bias::Right {
894 break;
895 } else {
896 cursor.next();
897 }
898 }
899 return cursor.end().1;
900 } else {
901 let overshoot = point - cursor.start().0;
902 return InlayPoint(cursor.start().1.0 + overshoot);
903 }
904 }
905 Some(Transform::Inlay(inlay)) => {
906 if inlay.position.bias() == Bias::Left {
907 cursor.next();
908 } else {
909 return cursor.start().1;
910 }
911 }
912 None => {
913 return self.max_point();
914 }
915 }
916 }
917 }
918
919 pub fn clip_point(&self, mut point: InlayPoint, mut bias: Bias) -> InlayPoint {
920 let mut cursor = self.transforms.cursor::<Dimensions<InlayPoint, Point>>(&());
921 cursor.seek(&point, Bias::Left);
922 loop {
923 match cursor.item() {
924 Some(Transform::Isomorphic(transform)) => {
925 if cursor.start().0 == point {
926 if let Some(Transform::Inlay(inlay)) = cursor.prev_item() {
927 if inlay.position.bias() == Bias::Left {
928 return point;
929 } else if bias == Bias::Left {
930 cursor.prev();
931 } else if transform.first_line_chars == 0 {
932 point.0 += Point::new(1, 0);
933 } else {
934 point.0 += Point::new(0, 1);
935 }
936 } else {
937 return point;
938 }
939 } else if cursor.end().0 == point {
940 if let Some(Transform::Inlay(inlay)) = cursor.next_item() {
941 if inlay.position.bias() == Bias::Right {
942 return point;
943 } else if bias == Bias::Right {
944 cursor.next();
945 } else if point.0.column == 0 {
946 point.0.row -= 1;
947 point.0.column = self.line_len(point.0.row);
948 } else {
949 point.0.column -= 1;
950 }
951 } else {
952 return point;
953 }
954 } else {
955 let overshoot = point.0 - cursor.start().0.0;
956 let buffer_point = cursor.start().1 + overshoot;
957 let clipped_buffer_point = self.buffer.clip_point(buffer_point, bias);
958 let clipped_overshoot = clipped_buffer_point - cursor.start().1;
959 let clipped_point = InlayPoint(cursor.start().0.0 + clipped_overshoot);
960 if clipped_point == point {
961 return clipped_point;
962 } else {
963 point = clipped_point;
964 }
965 }
966 }
967 Some(Transform::Inlay(inlay)) => {
968 if point == cursor.start().0 && inlay.position.bias() == Bias::Right {
969 match cursor.prev_item() {
970 Some(Transform::Inlay(inlay)) => {
971 if inlay.position.bias() == Bias::Left {
972 return point;
973 }
974 }
975 _ => return point,
976 }
977 } else if point == cursor.end().0 && inlay.position.bias() == Bias::Left {
978 match cursor.next_item() {
979 Some(Transform::Inlay(inlay)) => {
980 if inlay.position.bias() == Bias::Right {
981 return point;
982 }
983 }
984 _ => return point,
985 }
986 }
987
988 if bias == Bias::Left {
989 point = cursor.start().0;
990 cursor.prev();
991 } else {
992 cursor.next();
993 point = cursor.start().0;
994 }
995 }
996 None => {
997 bias = bias.invert();
998 if bias == Bias::Left {
999 point = cursor.start().0;
1000 cursor.prev();
1001 } else {
1002 cursor.next();
1003 point = cursor.start().0;
1004 }
1005 }
1006 }
1007 }
1008 }
1009
1010 pub fn text_summary(&self) -> TextSummary {
1011 self.transforms.summary().output
1012 }
1013
1014 pub fn text_summary_for_range(&self, range: Range<InlayOffset>) -> TextSummary {
1015 let mut summary = TextSummary::default();
1016
1017 let mut cursor = self
1018 .transforms
1019 .cursor::<Dimensions<InlayOffset, usize>>(&());
1020 cursor.seek(&range.start, Bias::Right);
1021
1022 let overshoot = range.start.0 - cursor.start().0.0;
1023 match cursor.item() {
1024 Some(Transform::Isomorphic(_)) => {
1025 let buffer_start = cursor.start().1;
1026 let suffix_start = buffer_start + overshoot;
1027 let suffix_end =
1028 buffer_start + (cmp::min(cursor.end().0, range.end).0 - cursor.start().0.0);
1029 summary = self.buffer.text_summary_for_range(suffix_start..suffix_end);
1030 cursor.next();
1031 }
1032 Some(Transform::Inlay(inlay)) => {
1033 let suffix_start = overshoot;
1034 let suffix_end = cmp::min(cursor.end().0, range.end).0 - cursor.start().0.0;
1035 summary = inlay.text.cursor(suffix_start).summary(suffix_end);
1036 cursor.next();
1037 }
1038 None => {}
1039 }
1040
1041 if range.end > cursor.start().0 {
1042 summary += cursor
1043 .summary::<_, TransformSummary>(&range.end, Bias::Right)
1044 .output;
1045
1046 let overshoot = range.end.0 - cursor.start().0.0;
1047 match cursor.item() {
1048 Some(Transform::Isomorphic(_)) => {
1049 let prefix_start = cursor.start().1;
1050 let prefix_end = prefix_start + overshoot;
1051 summary += self
1052 .buffer
1053 .text_summary_for_range::<TextSummary, _>(prefix_start..prefix_end);
1054 }
1055 Some(Transform::Inlay(inlay)) => {
1056 let prefix_end = overshoot;
1057 summary += inlay.text.cursor(0).summary::<TextSummary>(prefix_end);
1058 }
1059 None => {}
1060 }
1061 }
1062
1063 summary
1064 }
1065
1066 pub fn row_infos(&self, row: u32) -> InlayBufferRows<'_> {
1067 let mut cursor = self.transforms.cursor::<Dimensions<InlayPoint, Point>>(&());
1068 let inlay_point = InlayPoint::new(row, 0);
1069 cursor.seek(&inlay_point, Bias::Left);
1070
1071 let max_buffer_row = self.buffer.max_row();
1072 let mut buffer_point = cursor.start().1;
1073 let buffer_row = if row == 0 {
1074 MultiBufferRow(0)
1075 } else {
1076 match cursor.item() {
1077 Some(Transform::Isomorphic(_)) => {
1078 buffer_point += inlay_point.0 - cursor.start().0.0;
1079 MultiBufferRow(buffer_point.row)
1080 }
1081 _ => cmp::min(MultiBufferRow(buffer_point.row + 1), max_buffer_row),
1082 }
1083 };
1084
1085 InlayBufferRows {
1086 transforms: cursor,
1087 inlay_row: inlay_point.row(),
1088 buffer_rows: self.buffer.row_infos(buffer_row),
1089 max_buffer_row,
1090 }
1091 }
1092
1093 pub fn line_len(&self, row: u32) -> u32 {
1094 let line_start = self.to_offset(InlayPoint::new(row, 0)).0;
1095 let line_end = if row >= self.max_point().row() {
1096 self.len().0
1097 } else {
1098 self.to_offset(InlayPoint::new(row + 1, 0)).0 - 1
1099 };
1100 (line_end - line_start) as u32
1101 }
1102
1103 pub(crate) fn chunks<'a>(
1104 &'a self,
1105 range: Range<InlayOffset>,
1106 language_aware: bool,
1107 highlights: Highlights<'a>,
1108 ) -> InlayChunks<'a> {
1109 let mut cursor = self
1110 .transforms
1111 .cursor::<Dimensions<InlayOffset, usize>>(&());
1112 cursor.seek(&range.start, Bias::Right);
1113
1114 let buffer_range = self.to_buffer_offset(range.start)..self.to_buffer_offset(range.end);
1115 let buffer_chunks = CustomHighlightsChunks::new(
1116 buffer_range,
1117 language_aware,
1118 highlights.text_highlights,
1119 &self.buffer,
1120 );
1121
1122 InlayChunks {
1123 transforms: cursor,
1124 buffer_chunks,
1125 inlay_chunks: None,
1126 inlay_chunk: None,
1127 buffer_chunk: None,
1128 output_offset: range.start,
1129 max_output_offset: range.end,
1130 highlight_styles: highlights.styles,
1131 highlights,
1132 snapshot: self,
1133 }
1134 }
1135
1136 #[cfg(test)]
1137 pub fn text(&self) -> String {
1138 self.chunks(Default::default()..self.len(), false, Highlights::default())
1139 .map(|chunk| chunk.chunk.text)
1140 .collect()
1141 }
1142
1143 fn check_invariants(&self) {
1144 #[cfg(any(debug_assertions, feature = "test-support"))]
1145 {
1146 assert_eq!(self.transforms.summary().input, self.buffer.text_summary());
1147 let mut transforms = self.transforms.iter().peekable();
1148 while let Some(transform) = transforms.next() {
1149 let transform_is_isomorphic = matches!(transform, Transform::Isomorphic(_));
1150 if let Some(next_transform) = transforms.peek() {
1151 let next_transform_is_isomorphic =
1152 matches!(next_transform, Transform::Isomorphic(_));
1153 assert!(
1154 !transform_is_isomorphic || !next_transform_is_isomorphic,
1155 "two adjacent isomorphic transforms"
1156 );
1157 }
1158 }
1159 }
1160 }
1161}
1162
1163fn push_isomorphic(sum_tree: &mut SumTree<Transform>, summary: TextSummary) {
1164 if summary.len == 0 {
1165 return;
1166 }
1167
1168 let mut summary = Some(summary);
1169 sum_tree.update_last(
1170 |transform| {
1171 if let Transform::Isomorphic(transform) = transform {
1172 *transform += summary.take().unwrap();
1173 }
1174 },
1175 &(),
1176 );
1177
1178 if let Some(summary) = summary {
1179 sum_tree.push(Transform::Isomorphic(summary), &());
1180 }
1181}
1182
1183/// Given a byte index that is NOT a UTF-8 boundary, find the next one.
1184/// Assumes: 0 < byte_index < text.len() and !text.is_char_boundary(byte_index)
1185#[inline(always)]
1186fn find_next_utf8_boundary(text: &str, byte_index: usize) -> usize {
1187 let bytes = text.as_bytes();
1188 let mut idx = byte_index + 1;
1189
1190 // Scan forward until we find a boundary
1191 while idx < text.len() {
1192 if is_utf8_char_boundary(bytes[idx]) {
1193 return idx;
1194 }
1195 idx += 1;
1196 }
1197
1198 // Hit the end, return the full length
1199 text.len()
1200}
1201
1202// Private helper function taken from Rust's core::num module (which is both Apache2 and MIT licensed)
1203const fn is_utf8_char_boundary(byte: u8) -> bool {
1204 // This is bit magic equivalent to: b < 128 || b >= 192
1205 (byte as i8) >= -0x40
1206}
1207
1208#[cfg(test)]
1209mod tests {
1210 use super::*;
1211 use crate::{
1212 InlayId, MultiBuffer,
1213 display_map::{HighlightKey, InlayHighlights, TextHighlights},
1214 hover_links::InlayHighlight,
1215 };
1216 use gpui::{App, HighlightStyle};
1217 use project::{InlayHint, InlayHintLabel, ResolveState};
1218 use rand::prelude::*;
1219 use settings::SettingsStore;
1220 use std::{any::TypeId, cmp::Reverse, env, sync::Arc};
1221 use sum_tree::TreeMap;
1222 use text::Patch;
1223 use util::post_inc;
1224
1225 #[test]
1226 fn test_inlay_properties_label_padding() {
1227 assert_eq!(
1228 Inlay::hint(
1229 0,
1230 Anchor::min(),
1231 &InlayHint {
1232 label: InlayHintLabel::String("a".to_string()),
1233 position: text::Anchor::default(),
1234 padding_left: false,
1235 padding_right: false,
1236 tooltip: None,
1237 kind: None,
1238 resolve_state: ResolveState::Resolved,
1239 },
1240 )
1241 .text
1242 .to_string(),
1243 "a",
1244 "Should not pad label if not requested"
1245 );
1246
1247 assert_eq!(
1248 Inlay::hint(
1249 0,
1250 Anchor::min(),
1251 &InlayHint {
1252 label: InlayHintLabel::String("a".to_string()),
1253 position: text::Anchor::default(),
1254 padding_left: true,
1255 padding_right: true,
1256 tooltip: None,
1257 kind: None,
1258 resolve_state: ResolveState::Resolved,
1259 },
1260 )
1261 .text
1262 .to_string(),
1263 " a ",
1264 "Should pad label for every side requested"
1265 );
1266
1267 assert_eq!(
1268 Inlay::hint(
1269 0,
1270 Anchor::min(),
1271 &InlayHint {
1272 label: InlayHintLabel::String(" a ".to_string()),
1273 position: text::Anchor::default(),
1274 padding_left: false,
1275 padding_right: false,
1276 tooltip: None,
1277 kind: None,
1278 resolve_state: ResolveState::Resolved,
1279 },
1280 )
1281 .text
1282 .to_string(),
1283 " a ",
1284 "Should not change already padded label"
1285 );
1286
1287 assert_eq!(
1288 Inlay::hint(
1289 0,
1290 Anchor::min(),
1291 &InlayHint {
1292 label: InlayHintLabel::String(" a ".to_string()),
1293 position: text::Anchor::default(),
1294 padding_left: true,
1295 padding_right: true,
1296 tooltip: None,
1297 kind: None,
1298 resolve_state: ResolveState::Resolved,
1299 },
1300 )
1301 .text
1302 .to_string(),
1303 " a ",
1304 "Should not change already padded label"
1305 );
1306 }
1307
1308 #[gpui::test]
1309 fn test_inlay_hint_padding_with_multibyte_chars() {
1310 assert_eq!(
1311 Inlay::hint(
1312 0,
1313 Anchor::min(),
1314 &InlayHint {
1315 label: InlayHintLabel::String("🎨".to_string()),
1316 position: text::Anchor::default(),
1317 padding_left: true,
1318 padding_right: true,
1319 tooltip: None,
1320 kind: None,
1321 resolve_state: ResolveState::Resolved,
1322 },
1323 )
1324 .text
1325 .to_string(),
1326 " 🎨 ",
1327 "Should pad single emoji correctly"
1328 );
1329 }
1330
1331 #[gpui::test]
1332 fn test_basic_inlays(cx: &mut App) {
1333 let buffer = MultiBuffer::build_simple("abcdefghi", cx);
1334 let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe());
1335 let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer.read(cx).snapshot(cx));
1336 assert_eq!(inlay_snapshot.text(), "abcdefghi");
1337 let mut next_inlay_id = 0;
1338
1339 let (inlay_snapshot, _) = inlay_map.splice(
1340 &[],
1341 vec![Inlay::mock_hint(
1342 post_inc(&mut next_inlay_id),
1343 buffer.read(cx).snapshot(cx).anchor_after(3),
1344 "|123|",
1345 )],
1346 );
1347 assert_eq!(inlay_snapshot.text(), "abc|123|defghi");
1348 assert_eq!(
1349 inlay_snapshot.to_inlay_point(Point::new(0, 0)),
1350 InlayPoint::new(0, 0)
1351 );
1352 assert_eq!(
1353 inlay_snapshot.to_inlay_point(Point::new(0, 1)),
1354 InlayPoint::new(0, 1)
1355 );
1356 assert_eq!(
1357 inlay_snapshot.to_inlay_point(Point::new(0, 2)),
1358 InlayPoint::new(0, 2)
1359 );
1360 assert_eq!(
1361 inlay_snapshot.to_inlay_point(Point::new(0, 3)),
1362 InlayPoint::new(0, 3)
1363 );
1364 assert_eq!(
1365 inlay_snapshot.to_inlay_point(Point::new(0, 4)),
1366 InlayPoint::new(0, 9)
1367 );
1368 assert_eq!(
1369 inlay_snapshot.to_inlay_point(Point::new(0, 5)),
1370 InlayPoint::new(0, 10)
1371 );
1372 assert_eq!(
1373 inlay_snapshot.clip_point(InlayPoint::new(0, 0), Bias::Left),
1374 InlayPoint::new(0, 0)
1375 );
1376 assert_eq!(
1377 inlay_snapshot.clip_point(InlayPoint::new(0, 0), Bias::Right),
1378 InlayPoint::new(0, 0)
1379 );
1380 assert_eq!(
1381 inlay_snapshot.clip_point(InlayPoint::new(0, 3), Bias::Left),
1382 InlayPoint::new(0, 3)
1383 );
1384 assert_eq!(
1385 inlay_snapshot.clip_point(InlayPoint::new(0, 3), Bias::Right),
1386 InlayPoint::new(0, 3)
1387 );
1388 assert_eq!(
1389 inlay_snapshot.clip_point(InlayPoint::new(0, 4), Bias::Left),
1390 InlayPoint::new(0, 3)
1391 );
1392 assert_eq!(
1393 inlay_snapshot.clip_point(InlayPoint::new(0, 4), Bias::Right),
1394 InlayPoint::new(0, 9)
1395 );
1396
1397 // Edits before or after the inlay should not affect it.
1398 buffer.update(cx, |buffer, cx| {
1399 buffer.edit([(2..3, "x"), (3..3, "y"), (4..4, "z")], None, cx)
1400 });
1401 let (inlay_snapshot, _) = inlay_map.sync(
1402 buffer.read(cx).snapshot(cx),
1403 buffer_edits.consume().into_inner(),
1404 );
1405 assert_eq!(inlay_snapshot.text(), "abxy|123|dzefghi");
1406
1407 // An edit surrounding the inlay should invalidate it.
1408 buffer.update(cx, |buffer, cx| buffer.edit([(4..5, "D")], None, cx));
1409 let (inlay_snapshot, _) = inlay_map.sync(
1410 buffer.read(cx).snapshot(cx),
1411 buffer_edits.consume().into_inner(),
1412 );
1413 assert_eq!(inlay_snapshot.text(), "abxyDzefghi");
1414
1415 let (inlay_snapshot, _) = inlay_map.splice(
1416 &[],
1417 vec![
1418 Inlay::mock_hint(
1419 post_inc(&mut next_inlay_id),
1420 buffer.read(cx).snapshot(cx).anchor_before(3),
1421 "|123|",
1422 ),
1423 Inlay::edit_prediction(
1424 post_inc(&mut next_inlay_id),
1425 buffer.read(cx).snapshot(cx).anchor_after(3),
1426 "|456|",
1427 ),
1428 ],
1429 );
1430 assert_eq!(inlay_snapshot.text(), "abx|123||456|yDzefghi");
1431
1432 // Edits ending where the inlay starts should not move it if it has a left bias.
1433 buffer.update(cx, |buffer, cx| buffer.edit([(3..3, "JKL")], None, cx));
1434 let (inlay_snapshot, _) = inlay_map.sync(
1435 buffer.read(cx).snapshot(cx),
1436 buffer_edits.consume().into_inner(),
1437 );
1438 assert_eq!(inlay_snapshot.text(), "abx|123|JKL|456|yDzefghi");
1439
1440 assert_eq!(
1441 inlay_snapshot.clip_point(InlayPoint::new(0, 0), Bias::Left),
1442 InlayPoint::new(0, 0)
1443 );
1444 assert_eq!(
1445 inlay_snapshot.clip_point(InlayPoint::new(0, 0), Bias::Right),
1446 InlayPoint::new(0, 0)
1447 );
1448
1449 assert_eq!(
1450 inlay_snapshot.clip_point(InlayPoint::new(0, 1), Bias::Left),
1451 InlayPoint::new(0, 1)
1452 );
1453 assert_eq!(
1454 inlay_snapshot.clip_point(InlayPoint::new(0, 1), Bias::Right),
1455 InlayPoint::new(0, 1)
1456 );
1457
1458 assert_eq!(
1459 inlay_snapshot.clip_point(InlayPoint::new(0, 2), Bias::Left),
1460 InlayPoint::new(0, 2)
1461 );
1462 assert_eq!(
1463 inlay_snapshot.clip_point(InlayPoint::new(0, 2), Bias::Right),
1464 InlayPoint::new(0, 2)
1465 );
1466
1467 assert_eq!(
1468 inlay_snapshot.clip_point(InlayPoint::new(0, 3), Bias::Left),
1469 InlayPoint::new(0, 2)
1470 );
1471 assert_eq!(
1472 inlay_snapshot.clip_point(InlayPoint::new(0, 3), Bias::Right),
1473 InlayPoint::new(0, 8)
1474 );
1475
1476 assert_eq!(
1477 inlay_snapshot.clip_point(InlayPoint::new(0, 4), Bias::Left),
1478 InlayPoint::new(0, 2)
1479 );
1480 assert_eq!(
1481 inlay_snapshot.clip_point(InlayPoint::new(0, 4), Bias::Right),
1482 InlayPoint::new(0, 8)
1483 );
1484
1485 assert_eq!(
1486 inlay_snapshot.clip_point(InlayPoint::new(0, 5), Bias::Left),
1487 InlayPoint::new(0, 2)
1488 );
1489 assert_eq!(
1490 inlay_snapshot.clip_point(InlayPoint::new(0, 5), Bias::Right),
1491 InlayPoint::new(0, 8)
1492 );
1493
1494 assert_eq!(
1495 inlay_snapshot.clip_point(InlayPoint::new(0, 6), Bias::Left),
1496 InlayPoint::new(0, 2)
1497 );
1498 assert_eq!(
1499 inlay_snapshot.clip_point(InlayPoint::new(0, 6), Bias::Right),
1500 InlayPoint::new(0, 8)
1501 );
1502
1503 assert_eq!(
1504 inlay_snapshot.clip_point(InlayPoint::new(0, 7), Bias::Left),
1505 InlayPoint::new(0, 2)
1506 );
1507 assert_eq!(
1508 inlay_snapshot.clip_point(InlayPoint::new(0, 7), Bias::Right),
1509 InlayPoint::new(0, 8)
1510 );
1511
1512 assert_eq!(
1513 inlay_snapshot.clip_point(InlayPoint::new(0, 8), Bias::Left),
1514 InlayPoint::new(0, 8)
1515 );
1516 assert_eq!(
1517 inlay_snapshot.clip_point(InlayPoint::new(0, 8), Bias::Right),
1518 InlayPoint::new(0, 8)
1519 );
1520
1521 assert_eq!(
1522 inlay_snapshot.clip_point(InlayPoint::new(0, 9), Bias::Left),
1523 InlayPoint::new(0, 9)
1524 );
1525 assert_eq!(
1526 inlay_snapshot.clip_point(InlayPoint::new(0, 9), Bias::Right),
1527 InlayPoint::new(0, 9)
1528 );
1529
1530 assert_eq!(
1531 inlay_snapshot.clip_point(InlayPoint::new(0, 10), Bias::Left),
1532 InlayPoint::new(0, 10)
1533 );
1534 assert_eq!(
1535 inlay_snapshot.clip_point(InlayPoint::new(0, 10), Bias::Right),
1536 InlayPoint::new(0, 10)
1537 );
1538
1539 assert_eq!(
1540 inlay_snapshot.clip_point(InlayPoint::new(0, 11), Bias::Left),
1541 InlayPoint::new(0, 11)
1542 );
1543 assert_eq!(
1544 inlay_snapshot.clip_point(InlayPoint::new(0, 11), Bias::Right),
1545 InlayPoint::new(0, 11)
1546 );
1547
1548 assert_eq!(
1549 inlay_snapshot.clip_point(InlayPoint::new(0, 12), Bias::Left),
1550 InlayPoint::new(0, 11)
1551 );
1552 assert_eq!(
1553 inlay_snapshot.clip_point(InlayPoint::new(0, 12), Bias::Right),
1554 InlayPoint::new(0, 17)
1555 );
1556
1557 assert_eq!(
1558 inlay_snapshot.clip_point(InlayPoint::new(0, 13), Bias::Left),
1559 InlayPoint::new(0, 11)
1560 );
1561 assert_eq!(
1562 inlay_snapshot.clip_point(InlayPoint::new(0, 13), Bias::Right),
1563 InlayPoint::new(0, 17)
1564 );
1565
1566 assert_eq!(
1567 inlay_snapshot.clip_point(InlayPoint::new(0, 14), Bias::Left),
1568 InlayPoint::new(0, 11)
1569 );
1570 assert_eq!(
1571 inlay_snapshot.clip_point(InlayPoint::new(0, 14), Bias::Right),
1572 InlayPoint::new(0, 17)
1573 );
1574
1575 assert_eq!(
1576 inlay_snapshot.clip_point(InlayPoint::new(0, 15), Bias::Left),
1577 InlayPoint::new(0, 11)
1578 );
1579 assert_eq!(
1580 inlay_snapshot.clip_point(InlayPoint::new(0, 15), Bias::Right),
1581 InlayPoint::new(0, 17)
1582 );
1583
1584 assert_eq!(
1585 inlay_snapshot.clip_point(InlayPoint::new(0, 16), Bias::Left),
1586 InlayPoint::new(0, 11)
1587 );
1588 assert_eq!(
1589 inlay_snapshot.clip_point(InlayPoint::new(0, 16), Bias::Right),
1590 InlayPoint::new(0, 17)
1591 );
1592
1593 assert_eq!(
1594 inlay_snapshot.clip_point(InlayPoint::new(0, 17), Bias::Left),
1595 InlayPoint::new(0, 17)
1596 );
1597 assert_eq!(
1598 inlay_snapshot.clip_point(InlayPoint::new(0, 17), Bias::Right),
1599 InlayPoint::new(0, 17)
1600 );
1601
1602 assert_eq!(
1603 inlay_snapshot.clip_point(InlayPoint::new(0, 18), Bias::Left),
1604 InlayPoint::new(0, 18)
1605 );
1606 assert_eq!(
1607 inlay_snapshot.clip_point(InlayPoint::new(0, 18), Bias::Right),
1608 InlayPoint::new(0, 18)
1609 );
1610
1611 // The inlays can be manually removed.
1612 let (inlay_snapshot, _) = inlay_map.splice(
1613 &inlay_map
1614 .inlays
1615 .iter()
1616 .map(|inlay| inlay.id)
1617 .collect::<Vec<InlayId>>(),
1618 Vec::new(),
1619 );
1620 assert_eq!(inlay_snapshot.text(), "abxJKLyDzefghi");
1621 }
1622
1623 #[gpui::test]
1624 fn test_inlay_buffer_rows(cx: &mut App) {
1625 let buffer = MultiBuffer::build_simple("abc\ndef\nghi", cx);
1626 let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer.read(cx).snapshot(cx));
1627 assert_eq!(inlay_snapshot.text(), "abc\ndef\nghi");
1628 let mut next_inlay_id = 0;
1629
1630 let (inlay_snapshot, _) = inlay_map.splice(
1631 &[],
1632 vec![
1633 Inlay::mock_hint(
1634 post_inc(&mut next_inlay_id),
1635 buffer.read(cx).snapshot(cx).anchor_before(0),
1636 "|123|\n",
1637 ),
1638 Inlay::mock_hint(
1639 post_inc(&mut next_inlay_id),
1640 buffer.read(cx).snapshot(cx).anchor_before(4),
1641 "|456|",
1642 ),
1643 Inlay::edit_prediction(
1644 post_inc(&mut next_inlay_id),
1645 buffer.read(cx).snapshot(cx).anchor_before(7),
1646 "\n|567|\n",
1647 ),
1648 ],
1649 );
1650 assert_eq!(inlay_snapshot.text(), "|123|\nabc\n|456|def\n|567|\n\nghi");
1651 assert_eq!(
1652 inlay_snapshot
1653 .row_infos(0)
1654 .map(|info| info.buffer_row)
1655 .collect::<Vec<_>>(),
1656 vec![Some(0), None, Some(1), None, None, Some(2)]
1657 );
1658 }
1659
1660 #[gpui::test(iterations = 100)]
1661 fn test_random_inlays(cx: &mut App, mut rng: StdRng) {
1662 init_test(cx);
1663
1664 let operations = env::var("OPERATIONS")
1665 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1666 .unwrap_or(10);
1667
1668 let len = rng.gen_range(0..30);
1669 let buffer = if rng.r#gen() {
1670 let text = util::RandomCharIter::new(&mut rng)
1671 .take(len)
1672 .collect::<String>();
1673 MultiBuffer::build_simple(&text, cx)
1674 } else {
1675 MultiBuffer::build_random(&mut rng, cx)
1676 };
1677 let mut buffer_snapshot = buffer.read(cx).snapshot(cx);
1678 let mut next_inlay_id = 0;
1679 log::info!("buffer text: {:?}", buffer_snapshot.text());
1680 let (mut inlay_map, mut inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
1681 for _ in 0..operations {
1682 let mut inlay_edits = Patch::default();
1683
1684 let mut prev_inlay_text = inlay_snapshot.text();
1685 let mut buffer_edits = Vec::new();
1686 match rng.gen_range(0..=100) {
1687 0..=50 => {
1688 let (snapshot, edits) = inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng);
1689 log::info!("mutated text: {:?}", snapshot.text());
1690 inlay_edits = Patch::new(edits);
1691 }
1692 _ => buffer.update(cx, |buffer, cx| {
1693 let subscription = buffer.subscribe();
1694 let edit_count = rng.gen_range(1..=5);
1695 buffer.randomly_mutate(&mut rng, edit_count, cx);
1696 buffer_snapshot = buffer.snapshot(cx);
1697 let edits = subscription.consume().into_inner();
1698 log::info!("editing {:?}", edits);
1699 buffer_edits.extend(edits);
1700 }),
1701 };
1702
1703 let (new_inlay_snapshot, new_inlay_edits) =
1704 inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
1705 inlay_snapshot = new_inlay_snapshot;
1706 inlay_edits = inlay_edits.compose(new_inlay_edits);
1707
1708 log::info!("buffer text: {:?}", buffer_snapshot.text());
1709 log::info!("inlay text: {:?}", inlay_snapshot.text());
1710
1711 let inlays = inlay_map
1712 .inlays
1713 .iter()
1714 .filter(|inlay| inlay.position.is_valid(&buffer_snapshot))
1715 .map(|inlay| {
1716 let offset = inlay.position.to_offset(&buffer_snapshot);
1717 (offset, inlay.clone())
1718 })
1719 .collect::<Vec<_>>();
1720 let mut expected_text = Rope::from(&buffer_snapshot.text());
1721 for (offset, inlay) in inlays.iter().rev() {
1722 expected_text.replace(*offset..*offset, &inlay.text.to_string());
1723 }
1724 assert_eq!(inlay_snapshot.text(), expected_text.to_string());
1725
1726 let expected_buffer_rows = inlay_snapshot.row_infos(0).collect::<Vec<_>>();
1727 assert_eq!(
1728 expected_buffer_rows.len() as u32,
1729 expected_text.max_point().row + 1
1730 );
1731 for row_start in 0..expected_buffer_rows.len() {
1732 assert_eq!(
1733 inlay_snapshot
1734 .row_infos(row_start as u32)
1735 .collect::<Vec<_>>(),
1736 &expected_buffer_rows[row_start..],
1737 "incorrect buffer rows starting at {}",
1738 row_start
1739 );
1740 }
1741
1742 let mut text_highlights = TextHighlights::default();
1743 let text_highlight_count = rng.gen_range(0_usize..10);
1744 let mut text_highlight_ranges = (0..text_highlight_count)
1745 .map(|_| buffer_snapshot.random_byte_range(0, &mut rng))
1746 .collect::<Vec<_>>();
1747 text_highlight_ranges.sort_by_key(|range| (range.start, Reverse(range.end)));
1748 log::info!("highlighting text ranges {text_highlight_ranges:?}");
1749 text_highlights.insert(
1750 HighlightKey::Type(TypeId::of::<()>()),
1751 Arc::new((
1752 HighlightStyle::default(),
1753 text_highlight_ranges
1754 .into_iter()
1755 .map(|range| {
1756 buffer_snapshot.anchor_before(range.start)
1757 ..buffer_snapshot.anchor_after(range.end)
1758 })
1759 .collect(),
1760 )),
1761 );
1762
1763 let mut inlay_highlights = InlayHighlights::default();
1764 if !inlays.is_empty() {
1765 let inlay_highlight_count = rng.gen_range(0..inlays.len());
1766 let mut inlay_indices = BTreeSet::default();
1767 while inlay_indices.len() < inlay_highlight_count {
1768 inlay_indices.insert(rng.gen_range(0..inlays.len()));
1769 }
1770 let new_highlights = TreeMap::from_ordered_entries(
1771 inlay_indices
1772 .into_iter()
1773 .filter_map(|i| {
1774 let (_, inlay) = &inlays[i];
1775 let inlay_text_len = inlay.text.len();
1776 match inlay_text_len {
1777 0 => None,
1778 1 => Some(InlayHighlight {
1779 inlay: inlay.id,
1780 inlay_position: inlay.position,
1781 range: 0..1,
1782 }),
1783 n => {
1784 let inlay_text = inlay.text.to_string();
1785 let mut highlight_end = rng.gen_range(1..n);
1786 let mut highlight_start = rng.gen_range(0..highlight_end);
1787 while !inlay_text.is_char_boundary(highlight_end) {
1788 highlight_end += 1;
1789 }
1790 while !inlay_text.is_char_boundary(highlight_start) {
1791 highlight_start -= 1;
1792 }
1793 Some(InlayHighlight {
1794 inlay: inlay.id,
1795 inlay_position: inlay.position,
1796 range: highlight_start..highlight_end,
1797 })
1798 }
1799 }
1800 })
1801 .map(|highlight| (highlight.inlay, (HighlightStyle::default(), highlight))),
1802 );
1803 log::info!("highlighting inlay ranges {new_highlights:?}");
1804 inlay_highlights.insert(TypeId::of::<()>(), new_highlights);
1805 }
1806
1807 for _ in 0..5 {
1808 let mut end = rng.gen_range(0..=inlay_snapshot.len().0);
1809 end = expected_text.clip_offset(end, Bias::Right);
1810 let mut start = rng.gen_range(0..=end);
1811 start = expected_text.clip_offset(start, Bias::Right);
1812
1813 let range = InlayOffset(start)..InlayOffset(end);
1814 log::info!("calling inlay_snapshot.chunks({range:?})");
1815 let actual_text = inlay_snapshot
1816 .chunks(
1817 range,
1818 false,
1819 Highlights {
1820 text_highlights: Some(&text_highlights),
1821 inlay_highlights: Some(&inlay_highlights),
1822 ..Highlights::default()
1823 },
1824 )
1825 .map(|chunk| chunk.chunk.text)
1826 .collect::<String>();
1827 assert_eq!(
1828 actual_text,
1829 expected_text.slice(start..end).to_string(),
1830 "incorrect text in range {:?}",
1831 start..end
1832 );
1833
1834 assert_eq!(
1835 inlay_snapshot.text_summary_for_range(InlayOffset(start)..InlayOffset(end)),
1836 expected_text.slice(start..end).summary()
1837 );
1838 }
1839
1840 for edit in inlay_edits {
1841 prev_inlay_text.replace_range(
1842 edit.new.start.0..edit.new.start.0 + edit.old_len().0,
1843 &inlay_snapshot.text()[edit.new.start.0..edit.new.end.0],
1844 );
1845 }
1846 assert_eq!(prev_inlay_text, inlay_snapshot.text());
1847
1848 assert_eq!(expected_text.max_point(), inlay_snapshot.max_point().0);
1849 assert_eq!(expected_text.len(), inlay_snapshot.len().0);
1850
1851 let mut buffer_point = Point::default();
1852 let mut inlay_point = inlay_snapshot.to_inlay_point(buffer_point);
1853 let mut buffer_chars = buffer_snapshot.chars_at(0);
1854 loop {
1855 // Ensure conversion from buffer coordinates to inlay coordinates
1856 // is consistent.
1857 let buffer_offset = buffer_snapshot.point_to_offset(buffer_point);
1858 assert_eq!(
1859 inlay_snapshot.to_point(inlay_snapshot.to_inlay_offset(buffer_offset)),
1860 inlay_point
1861 );
1862
1863 // No matter which bias we clip an inlay point with, it doesn't move
1864 // because it was constructed from a buffer point.
1865 assert_eq!(
1866 inlay_snapshot.clip_point(inlay_point, Bias::Left),
1867 inlay_point,
1868 "invalid inlay point for buffer point {:?} when clipped left",
1869 buffer_point
1870 );
1871 assert_eq!(
1872 inlay_snapshot.clip_point(inlay_point, Bias::Right),
1873 inlay_point,
1874 "invalid inlay point for buffer point {:?} when clipped right",
1875 buffer_point
1876 );
1877
1878 if let Some(ch) = buffer_chars.next() {
1879 if ch == '\n' {
1880 buffer_point += Point::new(1, 0);
1881 } else {
1882 buffer_point += Point::new(0, ch.len_utf8() as u32);
1883 }
1884
1885 // Ensure that moving forward in the buffer always moves the inlay point forward as well.
1886 let new_inlay_point = inlay_snapshot.to_inlay_point(buffer_point);
1887 assert!(new_inlay_point > inlay_point);
1888 inlay_point = new_inlay_point;
1889 } else {
1890 break;
1891 }
1892 }
1893
1894 let mut inlay_point = InlayPoint::default();
1895 let mut inlay_offset = InlayOffset::default();
1896 for ch in expected_text.chars() {
1897 assert_eq!(
1898 inlay_snapshot.to_offset(inlay_point),
1899 inlay_offset,
1900 "invalid to_offset({:?})",
1901 inlay_point
1902 );
1903 assert_eq!(
1904 inlay_snapshot.to_point(inlay_offset),
1905 inlay_point,
1906 "invalid to_point({:?})",
1907 inlay_offset
1908 );
1909
1910 let mut bytes = [0; 4];
1911 for byte in ch.encode_utf8(&mut bytes).as_bytes() {
1912 inlay_offset.0 += 1;
1913 if *byte == b'\n' {
1914 inlay_point.0 += Point::new(1, 0);
1915 } else {
1916 inlay_point.0 += Point::new(0, 1);
1917 }
1918
1919 let clipped_left_point = inlay_snapshot.clip_point(inlay_point, Bias::Left);
1920 let clipped_right_point = inlay_snapshot.clip_point(inlay_point, Bias::Right);
1921 assert!(
1922 clipped_left_point <= clipped_right_point,
1923 "inlay point {:?} when clipped left is greater than when clipped right ({:?} > {:?})",
1924 inlay_point,
1925 clipped_left_point,
1926 clipped_right_point
1927 );
1928
1929 // Ensure the clipped points are at valid text locations.
1930 assert_eq!(
1931 clipped_left_point.0,
1932 expected_text.clip_point(clipped_left_point.0, Bias::Left)
1933 );
1934 assert_eq!(
1935 clipped_right_point.0,
1936 expected_text.clip_point(clipped_right_point.0, Bias::Right)
1937 );
1938
1939 // Ensure the clipped points never overshoot the end of the map.
1940 assert!(clipped_left_point <= inlay_snapshot.max_point());
1941 assert!(clipped_right_point <= inlay_snapshot.max_point());
1942
1943 // Ensure the clipped points are at valid buffer locations.
1944 assert_eq!(
1945 inlay_snapshot
1946 .to_inlay_point(inlay_snapshot.to_buffer_point(clipped_left_point)),
1947 clipped_left_point,
1948 "to_buffer_point({:?}) = {:?}",
1949 clipped_left_point,
1950 inlay_snapshot.to_buffer_point(clipped_left_point),
1951 );
1952 assert_eq!(
1953 inlay_snapshot
1954 .to_inlay_point(inlay_snapshot.to_buffer_point(clipped_right_point)),
1955 clipped_right_point,
1956 "to_buffer_point({:?}) = {:?}",
1957 clipped_right_point,
1958 inlay_snapshot.to_buffer_point(clipped_right_point),
1959 );
1960 }
1961 }
1962 }
1963 }
1964
1965 fn init_test(cx: &mut App) {
1966 let store = SettingsStore::test(cx);
1967 cx.set_global(store);
1968 theme::init(theme::LoadThemes::JustBase, cx);
1969 }
1970
1971 /// Helper to create test highlights for an inlay
1972 fn create_inlay_highlights(
1973 inlay_id: InlayId,
1974 highlight_range: Range<usize>,
1975 position: Anchor,
1976 ) -> TreeMap<TypeId, TreeMap<InlayId, (HighlightStyle, InlayHighlight)>> {
1977 let mut inlay_highlights = TreeMap::default();
1978 let mut type_highlights = TreeMap::default();
1979 type_highlights.insert(
1980 inlay_id,
1981 (
1982 HighlightStyle::default(),
1983 InlayHighlight {
1984 inlay: inlay_id,
1985 range: highlight_range,
1986 inlay_position: position,
1987 },
1988 ),
1989 );
1990 inlay_highlights.insert(TypeId::of::<()>(), type_highlights);
1991 inlay_highlights
1992 }
1993
1994 #[gpui::test]
1995 fn test_inlay_utf8_boundary_panic_fix(cx: &mut App) {
1996 init_test(cx);
1997
1998 // This test verifies that we handle UTF-8 character boundaries correctly
1999 // when splitting inlay text for highlighting. Previously, this would panic
2000 // when trying to split at byte 13, which is in the middle of the '…' character.
2001 //
2002 // See https://github.com/zed-industries/zed/issues/33641
2003 let buffer = MultiBuffer::build_simple("fn main() {}\n", cx);
2004 let (mut inlay_map, _) = InlayMap::new(buffer.read(cx).snapshot(cx));
2005
2006 // Create an inlay with text that contains a multi-byte character
2007 // The string "SortingDirec…" contains an ellipsis character '…' which is 3 bytes (E2 80 A6)
2008 let inlay_text = "SortingDirec…";
2009 let position = buffer.read(cx).snapshot(cx).anchor_before(Point::new(0, 5));
2010
2011 let inlay = Inlay {
2012 id: InlayId::Hint(0),
2013 position,
2014 text: text::Rope::from(inlay_text),
2015 color: None,
2016 };
2017
2018 let (inlay_snapshot, _) = inlay_map.splice(&[], vec![inlay]);
2019
2020 // Create highlights that request a split at byte 13, which is in the middle
2021 // of the '…' character (bytes 12..15). We include the full character.
2022 let inlay_highlights = create_inlay_highlights(InlayId::Hint(0), 0..13, position);
2023
2024 let highlights = crate::display_map::Highlights {
2025 text_highlights: None,
2026 inlay_highlights: Some(&inlay_highlights),
2027 styles: crate::display_map::HighlightStyles::default(),
2028 };
2029
2030 // Collect chunks - this previously would panic
2031 let chunks: Vec<_> = inlay_snapshot
2032 .chunks(
2033 InlayOffset(0)..InlayOffset(inlay_snapshot.len().0),
2034 false,
2035 highlights,
2036 )
2037 .collect();
2038
2039 // Verify the chunks are correct
2040 let full_text: String = chunks.iter().map(|c| c.chunk.text).collect();
2041 assert_eq!(full_text, "fn maSortingDirec…in() {}\n");
2042
2043 // Verify the highlighted portion includes the complete ellipsis character
2044 let highlighted_chunks: Vec<_> = chunks
2045 .iter()
2046 .filter(|c| c.chunk.highlight_style.is_some() && c.chunk.is_inlay)
2047 .collect();
2048
2049 assert_eq!(highlighted_chunks.len(), 1);
2050 assert_eq!(highlighted_chunks[0].chunk.text, "SortingDirec…");
2051 }
2052
2053 #[gpui::test]
2054 fn test_inlay_utf8_boundaries(cx: &mut App) {
2055 init_test(cx);
2056
2057 struct TestCase {
2058 inlay_text: &'static str,
2059 highlight_range: Range<usize>,
2060 expected_highlighted: &'static str,
2061 description: &'static str,
2062 }
2063
2064 let test_cases = vec![
2065 TestCase {
2066 inlay_text: "Hello👋World",
2067 highlight_range: 0..7,
2068 expected_highlighted: "Hello👋",
2069 description: "Emoji boundary - rounds up to include full emoji",
2070 },
2071 TestCase {
2072 inlay_text: "Test→End",
2073 highlight_range: 0..5,
2074 expected_highlighted: "Test→",
2075 description: "Arrow boundary - rounds up to include full arrow",
2076 },
2077 TestCase {
2078 inlay_text: "café",
2079 highlight_range: 0..4,
2080 expected_highlighted: "café",
2081 description: "Accented char boundary - rounds up to include full é",
2082 },
2083 TestCase {
2084 inlay_text: "🎨🎭🎪",
2085 highlight_range: 0..5,
2086 expected_highlighted: "🎨🎭",
2087 description: "Multiple emojis - partial highlight",
2088 },
2089 TestCase {
2090 inlay_text: "普通话",
2091 highlight_range: 0..4,
2092 expected_highlighted: "普通",
2093 description: "Chinese characters - partial highlight",
2094 },
2095 TestCase {
2096 inlay_text: "Hello",
2097 highlight_range: 0..2,
2098 expected_highlighted: "He",
2099 description: "ASCII only - no adjustment needed",
2100 },
2101 TestCase {
2102 inlay_text: "👋",
2103 highlight_range: 0..1,
2104 expected_highlighted: "👋",
2105 description: "Single emoji - partial byte range includes whole char",
2106 },
2107 TestCase {
2108 inlay_text: "Test",
2109 highlight_range: 0..0,
2110 expected_highlighted: "",
2111 description: "Empty range",
2112 },
2113 TestCase {
2114 inlay_text: "🎨ABC",
2115 highlight_range: 2..5,
2116 expected_highlighted: "A",
2117 description: "Range starting mid-emoji skips the emoji",
2118 },
2119 ];
2120
2121 for test_case in test_cases {
2122 let buffer = MultiBuffer::build_simple("test", cx);
2123 let (mut inlay_map, _) = InlayMap::new(buffer.read(cx).snapshot(cx));
2124 let position = buffer.read(cx).snapshot(cx).anchor_before(Point::new(0, 2));
2125
2126 let inlay = Inlay {
2127 id: InlayId::Hint(0),
2128 position,
2129 text: text::Rope::from(test_case.inlay_text),
2130 color: None,
2131 };
2132
2133 let (inlay_snapshot, _) = inlay_map.splice(&[], vec![inlay]);
2134 let inlay_highlights = create_inlay_highlights(
2135 InlayId::Hint(0),
2136 test_case.highlight_range.clone(),
2137 position,
2138 );
2139
2140 let highlights = crate::display_map::Highlights {
2141 text_highlights: None,
2142 inlay_highlights: Some(&inlay_highlights),
2143 styles: crate::display_map::HighlightStyles::default(),
2144 };
2145
2146 let chunks: Vec<_> = inlay_snapshot
2147 .chunks(
2148 InlayOffset(0)..InlayOffset(inlay_snapshot.len().0),
2149 false,
2150 highlights,
2151 )
2152 .collect();
2153
2154 // Verify we got chunks and they total to the expected text
2155 let full_text: String = chunks.iter().map(|c| c.chunk.text).collect();
2156 assert_eq!(
2157 full_text,
2158 format!("te{}st", test_case.inlay_text),
2159 "Full text mismatch for case: {}",
2160 test_case.description
2161 );
2162
2163 // Verify that the highlighted portion matches expectations
2164 let highlighted_text: String = chunks
2165 .iter()
2166 .filter(|c| c.chunk.highlight_style.is_some() && c.chunk.is_inlay)
2167 .map(|c| c.chunk.text)
2168 .collect();
2169 assert_eq!(
2170 highlighted_text, test_case.expected_highlighted,
2171 "Highlighted text mismatch for case: {} (text: '{}', range: {:?})",
2172 test_case.description, test_case.inlay_text, test_case.highlight_range
2173 );
2174 }
2175 }
2176}