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.chars_at(text.len().saturating_sub(1)).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                    if cursor.end().0 == buffer_edit.old.start {
 562                        push_isomorphic(&mut new_transforms, *transform);
 563                        cursor.next();
 564                    }
 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                    .map_or(true, |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_basic_inlays(cx: &mut App) {
1310        let buffer = MultiBuffer::build_simple("abcdefghi", cx);
1311        let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe());
1312        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer.read(cx).snapshot(cx));
1313        assert_eq!(inlay_snapshot.text(), "abcdefghi");
1314        let mut next_inlay_id = 0;
1315
1316        let (inlay_snapshot, _) = inlay_map.splice(
1317            &[],
1318            vec![Inlay::mock_hint(
1319                post_inc(&mut next_inlay_id),
1320                buffer.read(cx).snapshot(cx).anchor_after(3),
1321                "|123|",
1322            )],
1323        );
1324        assert_eq!(inlay_snapshot.text(), "abc|123|defghi");
1325        assert_eq!(
1326            inlay_snapshot.to_inlay_point(Point::new(0, 0)),
1327            InlayPoint::new(0, 0)
1328        );
1329        assert_eq!(
1330            inlay_snapshot.to_inlay_point(Point::new(0, 1)),
1331            InlayPoint::new(0, 1)
1332        );
1333        assert_eq!(
1334            inlay_snapshot.to_inlay_point(Point::new(0, 2)),
1335            InlayPoint::new(0, 2)
1336        );
1337        assert_eq!(
1338            inlay_snapshot.to_inlay_point(Point::new(0, 3)),
1339            InlayPoint::new(0, 3)
1340        );
1341        assert_eq!(
1342            inlay_snapshot.to_inlay_point(Point::new(0, 4)),
1343            InlayPoint::new(0, 9)
1344        );
1345        assert_eq!(
1346            inlay_snapshot.to_inlay_point(Point::new(0, 5)),
1347            InlayPoint::new(0, 10)
1348        );
1349        assert_eq!(
1350            inlay_snapshot.clip_point(InlayPoint::new(0, 0), Bias::Left),
1351            InlayPoint::new(0, 0)
1352        );
1353        assert_eq!(
1354            inlay_snapshot.clip_point(InlayPoint::new(0, 0), Bias::Right),
1355            InlayPoint::new(0, 0)
1356        );
1357        assert_eq!(
1358            inlay_snapshot.clip_point(InlayPoint::new(0, 3), Bias::Left),
1359            InlayPoint::new(0, 3)
1360        );
1361        assert_eq!(
1362            inlay_snapshot.clip_point(InlayPoint::new(0, 3), Bias::Right),
1363            InlayPoint::new(0, 3)
1364        );
1365        assert_eq!(
1366            inlay_snapshot.clip_point(InlayPoint::new(0, 4), Bias::Left),
1367            InlayPoint::new(0, 3)
1368        );
1369        assert_eq!(
1370            inlay_snapshot.clip_point(InlayPoint::new(0, 4), Bias::Right),
1371            InlayPoint::new(0, 9)
1372        );
1373
1374        // Edits before or after the inlay should not affect it.
1375        buffer.update(cx, |buffer, cx| {
1376            buffer.edit([(2..3, "x"), (3..3, "y"), (4..4, "z")], None, cx)
1377        });
1378        let (inlay_snapshot, _) = inlay_map.sync(
1379            buffer.read(cx).snapshot(cx),
1380            buffer_edits.consume().into_inner(),
1381        );
1382        assert_eq!(inlay_snapshot.text(), "abxy|123|dzefghi");
1383
1384        // An edit surrounding the inlay should invalidate it.
1385        buffer.update(cx, |buffer, cx| buffer.edit([(4..5, "D")], None, cx));
1386        let (inlay_snapshot, _) = inlay_map.sync(
1387            buffer.read(cx).snapshot(cx),
1388            buffer_edits.consume().into_inner(),
1389        );
1390        assert_eq!(inlay_snapshot.text(), "abxyDzefghi");
1391
1392        let (inlay_snapshot, _) = inlay_map.splice(
1393            &[],
1394            vec![
1395                Inlay::mock_hint(
1396                    post_inc(&mut next_inlay_id),
1397                    buffer.read(cx).snapshot(cx).anchor_before(3),
1398                    "|123|",
1399                ),
1400                Inlay::edit_prediction(
1401                    post_inc(&mut next_inlay_id),
1402                    buffer.read(cx).snapshot(cx).anchor_after(3),
1403                    "|456|",
1404                ),
1405            ],
1406        );
1407        assert_eq!(inlay_snapshot.text(), "abx|123||456|yDzefghi");
1408
1409        // Edits ending where the inlay starts should not move it if it has a left bias.
1410        buffer.update(cx, |buffer, cx| buffer.edit([(3..3, "JKL")], None, cx));
1411        let (inlay_snapshot, _) = inlay_map.sync(
1412            buffer.read(cx).snapshot(cx),
1413            buffer_edits.consume().into_inner(),
1414        );
1415        assert_eq!(inlay_snapshot.text(), "abx|123|JKL|456|yDzefghi");
1416
1417        assert_eq!(
1418            inlay_snapshot.clip_point(InlayPoint::new(0, 0), Bias::Left),
1419            InlayPoint::new(0, 0)
1420        );
1421        assert_eq!(
1422            inlay_snapshot.clip_point(InlayPoint::new(0, 0), Bias::Right),
1423            InlayPoint::new(0, 0)
1424        );
1425
1426        assert_eq!(
1427            inlay_snapshot.clip_point(InlayPoint::new(0, 1), Bias::Left),
1428            InlayPoint::new(0, 1)
1429        );
1430        assert_eq!(
1431            inlay_snapshot.clip_point(InlayPoint::new(0, 1), Bias::Right),
1432            InlayPoint::new(0, 1)
1433        );
1434
1435        assert_eq!(
1436            inlay_snapshot.clip_point(InlayPoint::new(0, 2), Bias::Left),
1437            InlayPoint::new(0, 2)
1438        );
1439        assert_eq!(
1440            inlay_snapshot.clip_point(InlayPoint::new(0, 2), Bias::Right),
1441            InlayPoint::new(0, 2)
1442        );
1443
1444        assert_eq!(
1445            inlay_snapshot.clip_point(InlayPoint::new(0, 3), Bias::Left),
1446            InlayPoint::new(0, 2)
1447        );
1448        assert_eq!(
1449            inlay_snapshot.clip_point(InlayPoint::new(0, 3), Bias::Right),
1450            InlayPoint::new(0, 8)
1451        );
1452
1453        assert_eq!(
1454            inlay_snapshot.clip_point(InlayPoint::new(0, 4), Bias::Left),
1455            InlayPoint::new(0, 2)
1456        );
1457        assert_eq!(
1458            inlay_snapshot.clip_point(InlayPoint::new(0, 4), Bias::Right),
1459            InlayPoint::new(0, 8)
1460        );
1461
1462        assert_eq!(
1463            inlay_snapshot.clip_point(InlayPoint::new(0, 5), Bias::Left),
1464            InlayPoint::new(0, 2)
1465        );
1466        assert_eq!(
1467            inlay_snapshot.clip_point(InlayPoint::new(0, 5), Bias::Right),
1468            InlayPoint::new(0, 8)
1469        );
1470
1471        assert_eq!(
1472            inlay_snapshot.clip_point(InlayPoint::new(0, 6), Bias::Left),
1473            InlayPoint::new(0, 2)
1474        );
1475        assert_eq!(
1476            inlay_snapshot.clip_point(InlayPoint::new(0, 6), Bias::Right),
1477            InlayPoint::new(0, 8)
1478        );
1479
1480        assert_eq!(
1481            inlay_snapshot.clip_point(InlayPoint::new(0, 7), Bias::Left),
1482            InlayPoint::new(0, 2)
1483        );
1484        assert_eq!(
1485            inlay_snapshot.clip_point(InlayPoint::new(0, 7), Bias::Right),
1486            InlayPoint::new(0, 8)
1487        );
1488
1489        assert_eq!(
1490            inlay_snapshot.clip_point(InlayPoint::new(0, 8), Bias::Left),
1491            InlayPoint::new(0, 8)
1492        );
1493        assert_eq!(
1494            inlay_snapshot.clip_point(InlayPoint::new(0, 8), Bias::Right),
1495            InlayPoint::new(0, 8)
1496        );
1497
1498        assert_eq!(
1499            inlay_snapshot.clip_point(InlayPoint::new(0, 9), Bias::Left),
1500            InlayPoint::new(0, 9)
1501        );
1502        assert_eq!(
1503            inlay_snapshot.clip_point(InlayPoint::new(0, 9), Bias::Right),
1504            InlayPoint::new(0, 9)
1505        );
1506
1507        assert_eq!(
1508            inlay_snapshot.clip_point(InlayPoint::new(0, 10), Bias::Left),
1509            InlayPoint::new(0, 10)
1510        );
1511        assert_eq!(
1512            inlay_snapshot.clip_point(InlayPoint::new(0, 10), Bias::Right),
1513            InlayPoint::new(0, 10)
1514        );
1515
1516        assert_eq!(
1517            inlay_snapshot.clip_point(InlayPoint::new(0, 11), Bias::Left),
1518            InlayPoint::new(0, 11)
1519        );
1520        assert_eq!(
1521            inlay_snapshot.clip_point(InlayPoint::new(0, 11), Bias::Right),
1522            InlayPoint::new(0, 11)
1523        );
1524
1525        assert_eq!(
1526            inlay_snapshot.clip_point(InlayPoint::new(0, 12), Bias::Left),
1527            InlayPoint::new(0, 11)
1528        );
1529        assert_eq!(
1530            inlay_snapshot.clip_point(InlayPoint::new(0, 12), Bias::Right),
1531            InlayPoint::new(0, 17)
1532        );
1533
1534        assert_eq!(
1535            inlay_snapshot.clip_point(InlayPoint::new(0, 13), Bias::Left),
1536            InlayPoint::new(0, 11)
1537        );
1538        assert_eq!(
1539            inlay_snapshot.clip_point(InlayPoint::new(0, 13), Bias::Right),
1540            InlayPoint::new(0, 17)
1541        );
1542
1543        assert_eq!(
1544            inlay_snapshot.clip_point(InlayPoint::new(0, 14), Bias::Left),
1545            InlayPoint::new(0, 11)
1546        );
1547        assert_eq!(
1548            inlay_snapshot.clip_point(InlayPoint::new(0, 14), Bias::Right),
1549            InlayPoint::new(0, 17)
1550        );
1551
1552        assert_eq!(
1553            inlay_snapshot.clip_point(InlayPoint::new(0, 15), Bias::Left),
1554            InlayPoint::new(0, 11)
1555        );
1556        assert_eq!(
1557            inlay_snapshot.clip_point(InlayPoint::new(0, 15), Bias::Right),
1558            InlayPoint::new(0, 17)
1559        );
1560
1561        assert_eq!(
1562            inlay_snapshot.clip_point(InlayPoint::new(0, 16), Bias::Left),
1563            InlayPoint::new(0, 11)
1564        );
1565        assert_eq!(
1566            inlay_snapshot.clip_point(InlayPoint::new(0, 16), Bias::Right),
1567            InlayPoint::new(0, 17)
1568        );
1569
1570        assert_eq!(
1571            inlay_snapshot.clip_point(InlayPoint::new(0, 17), Bias::Left),
1572            InlayPoint::new(0, 17)
1573        );
1574        assert_eq!(
1575            inlay_snapshot.clip_point(InlayPoint::new(0, 17), Bias::Right),
1576            InlayPoint::new(0, 17)
1577        );
1578
1579        assert_eq!(
1580            inlay_snapshot.clip_point(InlayPoint::new(0, 18), Bias::Left),
1581            InlayPoint::new(0, 18)
1582        );
1583        assert_eq!(
1584            inlay_snapshot.clip_point(InlayPoint::new(0, 18), Bias::Right),
1585            InlayPoint::new(0, 18)
1586        );
1587
1588        // The inlays can be manually removed.
1589        let (inlay_snapshot, _) = inlay_map.splice(
1590            &inlay_map
1591                .inlays
1592                .iter()
1593                .map(|inlay| inlay.id)
1594                .collect::<Vec<InlayId>>(),
1595            Vec::new(),
1596        );
1597        assert_eq!(inlay_snapshot.text(), "abxJKLyDzefghi");
1598    }
1599
1600    #[gpui::test]
1601    fn test_inlay_buffer_rows(cx: &mut App) {
1602        let buffer = MultiBuffer::build_simple("abc\ndef\nghi", cx);
1603        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer.read(cx).snapshot(cx));
1604        assert_eq!(inlay_snapshot.text(), "abc\ndef\nghi");
1605        let mut next_inlay_id = 0;
1606
1607        let (inlay_snapshot, _) = inlay_map.splice(
1608            &[],
1609            vec![
1610                Inlay::mock_hint(
1611                    post_inc(&mut next_inlay_id),
1612                    buffer.read(cx).snapshot(cx).anchor_before(0),
1613                    "|123|\n",
1614                ),
1615                Inlay::mock_hint(
1616                    post_inc(&mut next_inlay_id),
1617                    buffer.read(cx).snapshot(cx).anchor_before(4),
1618                    "|456|",
1619                ),
1620                Inlay::edit_prediction(
1621                    post_inc(&mut next_inlay_id),
1622                    buffer.read(cx).snapshot(cx).anchor_before(7),
1623                    "\n|567|\n",
1624                ),
1625            ],
1626        );
1627        assert_eq!(inlay_snapshot.text(), "|123|\nabc\n|456|def\n|567|\n\nghi");
1628        assert_eq!(
1629            inlay_snapshot
1630                .row_infos(0)
1631                .map(|info| info.buffer_row)
1632                .collect::<Vec<_>>(),
1633            vec![Some(0), None, Some(1), None, None, Some(2)]
1634        );
1635    }
1636
1637    #[gpui::test(iterations = 100)]
1638    fn test_random_inlays(cx: &mut App, mut rng: StdRng) {
1639        init_test(cx);
1640
1641        let operations = env::var("OPERATIONS")
1642            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1643            .unwrap_or(10);
1644
1645        let len = rng.gen_range(0..30);
1646        let buffer = if rng.r#gen() {
1647            let text = util::RandomCharIter::new(&mut rng)
1648                .take(len)
1649                .collect::<String>();
1650            MultiBuffer::build_simple(&text, cx)
1651        } else {
1652            MultiBuffer::build_random(&mut rng, cx)
1653        };
1654        let mut buffer_snapshot = buffer.read(cx).snapshot(cx);
1655        let mut next_inlay_id = 0;
1656        log::info!("buffer text: {:?}", buffer_snapshot.text());
1657        let (mut inlay_map, mut inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
1658        for _ in 0..operations {
1659            let mut inlay_edits = Patch::default();
1660
1661            let mut prev_inlay_text = inlay_snapshot.text();
1662            let mut buffer_edits = Vec::new();
1663            match rng.gen_range(0..=100) {
1664                0..=50 => {
1665                    let (snapshot, edits) = inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng);
1666                    log::info!("mutated text: {:?}", snapshot.text());
1667                    inlay_edits = Patch::new(edits);
1668                }
1669                _ => buffer.update(cx, |buffer, cx| {
1670                    let subscription = buffer.subscribe();
1671                    let edit_count = rng.gen_range(1..=5);
1672                    buffer.randomly_mutate(&mut rng, edit_count, cx);
1673                    buffer_snapshot = buffer.snapshot(cx);
1674                    let edits = subscription.consume().into_inner();
1675                    log::info!("editing {:?}", edits);
1676                    buffer_edits.extend(edits);
1677                }),
1678            };
1679
1680            let (new_inlay_snapshot, new_inlay_edits) =
1681                inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
1682            inlay_snapshot = new_inlay_snapshot;
1683            inlay_edits = inlay_edits.compose(new_inlay_edits);
1684
1685            log::info!("buffer text: {:?}", buffer_snapshot.text());
1686            log::info!("inlay text: {:?}", inlay_snapshot.text());
1687
1688            let inlays = inlay_map
1689                .inlays
1690                .iter()
1691                .filter(|inlay| inlay.position.is_valid(&buffer_snapshot))
1692                .map(|inlay| {
1693                    let offset = inlay.position.to_offset(&buffer_snapshot);
1694                    (offset, inlay.clone())
1695                })
1696                .collect::<Vec<_>>();
1697            let mut expected_text = Rope::from(&buffer_snapshot.text());
1698            for (offset, inlay) in inlays.iter().rev() {
1699                expected_text.replace(*offset..*offset, &inlay.text.to_string());
1700            }
1701            assert_eq!(inlay_snapshot.text(), expected_text.to_string());
1702
1703            let expected_buffer_rows = inlay_snapshot.row_infos(0).collect::<Vec<_>>();
1704            assert_eq!(
1705                expected_buffer_rows.len() as u32,
1706                expected_text.max_point().row + 1
1707            );
1708            for row_start in 0..expected_buffer_rows.len() {
1709                assert_eq!(
1710                    inlay_snapshot
1711                        .row_infos(row_start as u32)
1712                        .collect::<Vec<_>>(),
1713                    &expected_buffer_rows[row_start..],
1714                    "incorrect buffer rows starting at {}",
1715                    row_start
1716                );
1717            }
1718
1719            let mut text_highlights = TextHighlights::default();
1720            let text_highlight_count = rng.gen_range(0_usize..10);
1721            let mut text_highlight_ranges = (0..text_highlight_count)
1722                .map(|_| buffer_snapshot.random_byte_range(0, &mut rng))
1723                .collect::<Vec<_>>();
1724            text_highlight_ranges.sort_by_key(|range| (range.start, Reverse(range.end)));
1725            log::info!("highlighting text ranges {text_highlight_ranges:?}");
1726            text_highlights.insert(
1727                HighlightKey::Type(TypeId::of::<()>()),
1728                Arc::new((
1729                    HighlightStyle::default(),
1730                    text_highlight_ranges
1731                        .into_iter()
1732                        .map(|range| {
1733                            buffer_snapshot.anchor_before(range.start)
1734                                ..buffer_snapshot.anchor_after(range.end)
1735                        })
1736                        .collect(),
1737                )),
1738            );
1739
1740            let mut inlay_highlights = InlayHighlights::default();
1741            if !inlays.is_empty() {
1742                let inlay_highlight_count = rng.gen_range(0..inlays.len());
1743                let mut inlay_indices = BTreeSet::default();
1744                while inlay_indices.len() < inlay_highlight_count {
1745                    inlay_indices.insert(rng.gen_range(0..inlays.len()));
1746                }
1747                let new_highlights = TreeMap::from_ordered_entries(
1748                    inlay_indices
1749                        .into_iter()
1750                        .filter_map(|i| {
1751                            let (_, inlay) = &inlays[i];
1752                            let inlay_text_len = inlay.text.len();
1753                            match inlay_text_len {
1754                                0 => None,
1755                                1 => Some(InlayHighlight {
1756                                    inlay: inlay.id,
1757                                    inlay_position: inlay.position,
1758                                    range: 0..1,
1759                                }),
1760                                n => {
1761                                    let inlay_text = inlay.text.to_string();
1762                                    let mut highlight_end = rng.gen_range(1..n);
1763                                    let mut highlight_start = rng.gen_range(0..highlight_end);
1764                                    while !inlay_text.is_char_boundary(highlight_end) {
1765                                        highlight_end += 1;
1766                                    }
1767                                    while !inlay_text.is_char_boundary(highlight_start) {
1768                                        highlight_start -= 1;
1769                                    }
1770                                    Some(InlayHighlight {
1771                                        inlay: inlay.id,
1772                                        inlay_position: inlay.position,
1773                                        range: highlight_start..highlight_end,
1774                                    })
1775                                }
1776                            }
1777                        })
1778                        .map(|highlight| (highlight.inlay, (HighlightStyle::default(), highlight))),
1779                );
1780                log::info!("highlighting inlay ranges {new_highlights:?}");
1781                inlay_highlights.insert(TypeId::of::<()>(), new_highlights);
1782            }
1783
1784            for _ in 0..5 {
1785                let mut end = rng.gen_range(0..=inlay_snapshot.len().0);
1786                end = expected_text.clip_offset(end, Bias::Right);
1787                let mut start = rng.gen_range(0..=end);
1788                start = expected_text.clip_offset(start, Bias::Right);
1789
1790                let range = InlayOffset(start)..InlayOffset(end);
1791                log::info!("calling inlay_snapshot.chunks({range:?})");
1792                let actual_text = inlay_snapshot
1793                    .chunks(
1794                        range,
1795                        false,
1796                        Highlights {
1797                            text_highlights: Some(&text_highlights),
1798                            inlay_highlights: Some(&inlay_highlights),
1799                            ..Highlights::default()
1800                        },
1801                    )
1802                    .map(|chunk| chunk.chunk.text)
1803                    .collect::<String>();
1804                assert_eq!(
1805                    actual_text,
1806                    expected_text.slice(start..end).to_string(),
1807                    "incorrect text in range {:?}",
1808                    start..end
1809                );
1810
1811                assert_eq!(
1812                    inlay_snapshot.text_summary_for_range(InlayOffset(start)..InlayOffset(end)),
1813                    expected_text.slice(start..end).summary()
1814                );
1815            }
1816
1817            for edit in inlay_edits {
1818                prev_inlay_text.replace_range(
1819                    edit.new.start.0..edit.new.start.0 + edit.old_len().0,
1820                    &inlay_snapshot.text()[edit.new.start.0..edit.new.end.0],
1821                );
1822            }
1823            assert_eq!(prev_inlay_text, inlay_snapshot.text());
1824
1825            assert_eq!(expected_text.max_point(), inlay_snapshot.max_point().0);
1826            assert_eq!(expected_text.len(), inlay_snapshot.len().0);
1827
1828            let mut buffer_point = Point::default();
1829            let mut inlay_point = inlay_snapshot.to_inlay_point(buffer_point);
1830            let mut buffer_chars = buffer_snapshot.chars_at(0);
1831            loop {
1832                // Ensure conversion from buffer coordinates to inlay coordinates
1833                // is consistent.
1834                let buffer_offset = buffer_snapshot.point_to_offset(buffer_point);
1835                assert_eq!(
1836                    inlay_snapshot.to_point(inlay_snapshot.to_inlay_offset(buffer_offset)),
1837                    inlay_point
1838                );
1839
1840                // No matter which bias we clip an inlay point with, it doesn't move
1841                // because it was constructed from a buffer point.
1842                assert_eq!(
1843                    inlay_snapshot.clip_point(inlay_point, Bias::Left),
1844                    inlay_point,
1845                    "invalid inlay point for buffer point {:?} when clipped left",
1846                    buffer_point
1847                );
1848                assert_eq!(
1849                    inlay_snapshot.clip_point(inlay_point, Bias::Right),
1850                    inlay_point,
1851                    "invalid inlay point for buffer point {:?} when clipped right",
1852                    buffer_point
1853                );
1854
1855                if let Some(ch) = buffer_chars.next() {
1856                    if ch == '\n' {
1857                        buffer_point += Point::new(1, 0);
1858                    } else {
1859                        buffer_point += Point::new(0, ch.len_utf8() as u32);
1860                    }
1861
1862                    // Ensure that moving forward in the buffer always moves the inlay point forward as well.
1863                    let new_inlay_point = inlay_snapshot.to_inlay_point(buffer_point);
1864                    assert!(new_inlay_point > inlay_point);
1865                    inlay_point = new_inlay_point;
1866                } else {
1867                    break;
1868                }
1869            }
1870
1871            let mut inlay_point = InlayPoint::default();
1872            let mut inlay_offset = InlayOffset::default();
1873            for ch in expected_text.chars() {
1874                assert_eq!(
1875                    inlay_snapshot.to_offset(inlay_point),
1876                    inlay_offset,
1877                    "invalid to_offset({:?})",
1878                    inlay_point
1879                );
1880                assert_eq!(
1881                    inlay_snapshot.to_point(inlay_offset),
1882                    inlay_point,
1883                    "invalid to_point({:?})",
1884                    inlay_offset
1885                );
1886
1887                let mut bytes = [0; 4];
1888                for byte in ch.encode_utf8(&mut bytes).as_bytes() {
1889                    inlay_offset.0 += 1;
1890                    if *byte == b'\n' {
1891                        inlay_point.0 += Point::new(1, 0);
1892                    } else {
1893                        inlay_point.0 += Point::new(0, 1);
1894                    }
1895
1896                    let clipped_left_point = inlay_snapshot.clip_point(inlay_point, Bias::Left);
1897                    let clipped_right_point = inlay_snapshot.clip_point(inlay_point, Bias::Right);
1898                    assert!(
1899                        clipped_left_point <= clipped_right_point,
1900                        "inlay point {:?} when clipped left is greater than when clipped right ({:?} > {:?})",
1901                        inlay_point,
1902                        clipped_left_point,
1903                        clipped_right_point
1904                    );
1905
1906                    // Ensure the clipped points are at valid text locations.
1907                    assert_eq!(
1908                        clipped_left_point.0,
1909                        expected_text.clip_point(clipped_left_point.0, Bias::Left)
1910                    );
1911                    assert_eq!(
1912                        clipped_right_point.0,
1913                        expected_text.clip_point(clipped_right_point.0, Bias::Right)
1914                    );
1915
1916                    // Ensure the clipped points never overshoot the end of the map.
1917                    assert!(clipped_left_point <= inlay_snapshot.max_point());
1918                    assert!(clipped_right_point <= inlay_snapshot.max_point());
1919
1920                    // Ensure the clipped points are at valid buffer locations.
1921                    assert_eq!(
1922                        inlay_snapshot
1923                            .to_inlay_point(inlay_snapshot.to_buffer_point(clipped_left_point)),
1924                        clipped_left_point,
1925                        "to_buffer_point({:?}) = {:?}",
1926                        clipped_left_point,
1927                        inlay_snapshot.to_buffer_point(clipped_left_point),
1928                    );
1929                    assert_eq!(
1930                        inlay_snapshot
1931                            .to_inlay_point(inlay_snapshot.to_buffer_point(clipped_right_point)),
1932                        clipped_right_point,
1933                        "to_buffer_point({:?}) = {:?}",
1934                        clipped_right_point,
1935                        inlay_snapshot.to_buffer_point(clipped_right_point),
1936                    );
1937                }
1938            }
1939        }
1940    }
1941
1942    fn init_test(cx: &mut App) {
1943        let store = SettingsStore::test(cx);
1944        cx.set_global(store);
1945        theme::init(theme::LoadThemes::JustBase, cx);
1946    }
1947
1948    /// Helper to create test highlights for an inlay
1949    fn create_inlay_highlights(
1950        inlay_id: InlayId,
1951        highlight_range: Range<usize>,
1952        position: Anchor,
1953    ) -> TreeMap<TypeId, TreeMap<InlayId, (HighlightStyle, InlayHighlight)>> {
1954        let mut inlay_highlights = TreeMap::default();
1955        let mut type_highlights = TreeMap::default();
1956        type_highlights.insert(
1957            inlay_id,
1958            (
1959                HighlightStyle::default(),
1960                InlayHighlight {
1961                    inlay: inlay_id,
1962                    range: highlight_range,
1963                    inlay_position: position,
1964                },
1965            ),
1966        );
1967        inlay_highlights.insert(TypeId::of::<()>(), type_highlights);
1968        inlay_highlights
1969    }
1970
1971    #[gpui::test]
1972    fn test_inlay_utf8_boundary_panic_fix(cx: &mut App) {
1973        init_test(cx);
1974
1975        // This test verifies that we handle UTF-8 character boundaries correctly
1976        // when splitting inlay text for highlighting. Previously, this would panic
1977        // when trying to split at byte 13, which is in the middle of the '…' character.
1978        //
1979        // See https://github.com/zed-industries/zed/issues/33641
1980        let buffer = MultiBuffer::build_simple("fn main() {}\n", cx);
1981        let (mut inlay_map, _) = InlayMap::new(buffer.read(cx).snapshot(cx));
1982
1983        // Create an inlay with text that contains a multi-byte character
1984        // The string "SortingDirec…" contains an ellipsis character '…' which is 3 bytes (E2 80 A6)
1985        let inlay_text = "SortingDirec…";
1986        let position = buffer.read(cx).snapshot(cx).anchor_before(Point::new(0, 5));
1987
1988        let inlay = Inlay {
1989            id: InlayId::Hint(0),
1990            position,
1991            text: text::Rope::from(inlay_text),
1992            color: None,
1993        };
1994
1995        let (inlay_snapshot, _) = inlay_map.splice(&[], vec![inlay]);
1996
1997        // Create highlights that request a split at byte 13, which is in the middle
1998        // of the '…' character (bytes 12..15). We include the full character.
1999        let inlay_highlights = create_inlay_highlights(InlayId::Hint(0), 0..13, position);
2000
2001        let highlights = crate::display_map::Highlights {
2002            text_highlights: None,
2003            inlay_highlights: Some(&inlay_highlights),
2004            styles: crate::display_map::HighlightStyles::default(),
2005        };
2006
2007        // Collect chunks - this previously would panic
2008        let chunks: Vec<_> = inlay_snapshot
2009            .chunks(
2010                InlayOffset(0)..InlayOffset(inlay_snapshot.len().0),
2011                false,
2012                highlights,
2013            )
2014            .collect();
2015
2016        // Verify the chunks are correct
2017        let full_text: String = chunks.iter().map(|c| c.chunk.text).collect();
2018        assert_eq!(full_text, "fn maSortingDirec…in() {}\n");
2019
2020        // Verify the highlighted portion includes the complete ellipsis character
2021        let highlighted_chunks: Vec<_> = chunks
2022            .iter()
2023            .filter(|c| c.chunk.highlight_style.is_some() && c.chunk.is_inlay)
2024            .collect();
2025
2026        assert_eq!(highlighted_chunks.len(), 1);
2027        assert_eq!(highlighted_chunks[0].chunk.text, "SortingDirec…");
2028    }
2029
2030    #[gpui::test]
2031    fn test_inlay_utf8_boundaries(cx: &mut App) {
2032        init_test(cx);
2033
2034        struct TestCase {
2035            inlay_text: &'static str,
2036            highlight_range: Range<usize>,
2037            expected_highlighted: &'static str,
2038            description: &'static str,
2039        }
2040
2041        let test_cases = vec![
2042            TestCase {
2043                inlay_text: "Hello👋World",
2044                highlight_range: 0..7,
2045                expected_highlighted: "Hello👋",
2046                description: "Emoji boundary - rounds up to include full emoji",
2047            },
2048            TestCase {
2049                inlay_text: "Test→End",
2050                highlight_range: 0..5,
2051                expected_highlighted: "Test→",
2052                description: "Arrow boundary - rounds up to include full arrow",
2053            },
2054            TestCase {
2055                inlay_text: "café",
2056                highlight_range: 0..4,
2057                expected_highlighted: "café",
2058                description: "Accented char boundary - rounds up to include full é",
2059            },
2060            TestCase {
2061                inlay_text: "🎨🎭🎪",
2062                highlight_range: 0..5,
2063                expected_highlighted: "🎨🎭",
2064                description: "Multiple emojis - partial highlight",
2065            },
2066            TestCase {
2067                inlay_text: "普通话",
2068                highlight_range: 0..4,
2069                expected_highlighted: "普通",
2070                description: "Chinese characters - partial highlight",
2071            },
2072            TestCase {
2073                inlay_text: "Hello",
2074                highlight_range: 0..2,
2075                expected_highlighted: "He",
2076                description: "ASCII only - no adjustment needed",
2077            },
2078            TestCase {
2079                inlay_text: "👋",
2080                highlight_range: 0..1,
2081                expected_highlighted: "👋",
2082                description: "Single emoji - partial byte range includes whole char",
2083            },
2084            TestCase {
2085                inlay_text: "Test",
2086                highlight_range: 0..0,
2087                expected_highlighted: "",
2088                description: "Empty range",
2089            },
2090            TestCase {
2091                inlay_text: "🎨ABC",
2092                highlight_range: 2..5,
2093                expected_highlighted: "A",
2094                description: "Range starting mid-emoji skips the emoji",
2095            },
2096        ];
2097
2098        for test_case in test_cases {
2099            let buffer = MultiBuffer::build_simple("test", cx);
2100            let (mut inlay_map, _) = InlayMap::new(buffer.read(cx).snapshot(cx));
2101            let position = buffer.read(cx).snapshot(cx).anchor_before(Point::new(0, 2));
2102
2103            let inlay = Inlay {
2104                id: InlayId::Hint(0),
2105                position,
2106                text: text::Rope::from(test_case.inlay_text),
2107                color: None,
2108            };
2109
2110            let (inlay_snapshot, _) = inlay_map.splice(&[], vec![inlay]);
2111            let inlay_highlights = create_inlay_highlights(
2112                InlayId::Hint(0),
2113                test_case.highlight_range.clone(),
2114                position,
2115            );
2116
2117            let highlights = crate::display_map::Highlights {
2118                text_highlights: None,
2119                inlay_highlights: Some(&inlay_highlights),
2120                styles: crate::display_map::HighlightStyles::default(),
2121            };
2122
2123            let chunks: Vec<_> = inlay_snapshot
2124                .chunks(
2125                    InlayOffset(0)..InlayOffset(inlay_snapshot.len().0),
2126                    false,
2127                    highlights,
2128                )
2129                .collect();
2130
2131            // Verify we got chunks and they total to the expected text
2132            let full_text: String = chunks.iter().map(|c| c.chunk.text).collect();
2133            assert_eq!(
2134                full_text,
2135                format!("te{}st", test_case.inlay_text),
2136                "Full text mismatch for case: {}",
2137                test_case.description
2138            );
2139
2140            // Verify that the highlighted portion matches expectations
2141            let highlighted_text: String = chunks
2142                .iter()
2143                .filter(|c| c.chunk.highlight_style.is_some() && c.chunk.is_inlay)
2144                .map(|c| c.chunk.text)
2145                .collect();
2146            assert_eq!(
2147                highlighted_text, test_case.expected_highlighted,
2148                "Highlighted text mismatch for case: {} (text: '{}', range: {:?})",
2149                test_case.description, test_case.inlay_text, test_case.highlight_range
2150            );
2151        }
2152    }
2153}