1use crate::{
   2    Anchor, Editor, EditorSettings, EditorSnapshot, FindAllReferences, GoToDefinition,
   3    GoToDefinitionSplit, GoToTypeDefinition, GoToTypeDefinitionSplit, GotoDefinitionKind, InlayId,
   4    Navigated, PointForPosition, SelectPhase,
   5    editor_settings::GoToDefinitionFallback,
   6    hover_popover::{self, InlayHover},
   7    scroll::ScrollAmount,
   8};
   9use gpui::{App, AsyncWindowContext, Context, Entity, Modifiers, Task, Window, px};
  10use language::{Bias, ToOffset};
  11use linkify::{LinkFinder, LinkKind};
  12use lsp::LanguageServerId;
  13use project::{
  14    HoverBlock, HoverBlockKind, InlayHintLabelPartTooltip, InlayHintTooltip, LocationLink, Project,
  15    ResolveState, ResolvedPath,
  16};
  17use settings::Settings;
  18use std::ops::Range;
  19use theme::ActiveTheme as _;
  20use util::{ResultExt, TryFutureExt as _, maybe};
  21
  22#[derive(Debug)]
  23pub struct HoveredLinkState {
  24    pub last_trigger_point: TriggerPoint,
  25    pub preferred_kind: GotoDefinitionKind,
  26    pub symbol_range: Option<RangeInEditor>,
  27    pub links: Vec<HoverLink>,
  28    pub task: Option<Task<Option<()>>>,
  29}
  30
  31#[derive(Debug, Eq, PartialEq, Clone)]
  32pub enum RangeInEditor {
  33    Text(Range<Anchor>),
  34    Inlay(InlayHighlight),
  35}
  36
  37impl RangeInEditor {
  38    pub fn as_text_range(&self) -> Option<Range<Anchor>> {
  39        match self {
  40            Self::Text(range) => Some(range.clone()),
  41            Self::Inlay(_) => None,
  42        }
  43    }
  44
  45    pub fn point_within_range(
  46        &self,
  47        trigger_point: &TriggerPoint,
  48        snapshot: &EditorSnapshot,
  49    ) -> bool {
  50        match (self, trigger_point) {
  51            (Self::Text(range), TriggerPoint::Text(point)) => {
  52                let point_after_start = range.start.cmp(point, &snapshot.buffer_snapshot).is_le();
  53                point_after_start && range.end.cmp(point, &snapshot.buffer_snapshot).is_ge()
  54            }
  55            (Self::Inlay(highlight), TriggerPoint::InlayHint(point, _, _)) => {
  56                highlight.inlay == point.inlay
  57                    && highlight.range.contains(&point.range.start)
  58                    && highlight.range.contains(&point.range.end)
  59            }
  60            (Self::Inlay(_), TriggerPoint::Text(_))
  61            | (Self::Text(_), TriggerPoint::InlayHint(_, _, _)) => false,
  62        }
  63    }
  64}
  65
  66#[derive(Debug, Clone)]
  67pub enum HoverLink {
  68    Url(String),
  69    File(ResolvedPath),
  70    Text(LocationLink),
  71    InlayHint(lsp::Location, LanguageServerId),
  72}
  73
  74#[derive(Debug, Clone, PartialEq, Eq)]
  75pub struct InlayHighlight {
  76    pub inlay: InlayId,
  77    pub inlay_position: Anchor,
  78    pub range: Range<usize>,
  79}
  80
  81#[derive(Debug, Clone, PartialEq)]
  82pub enum TriggerPoint {
  83    Text(Anchor),
  84    InlayHint(InlayHighlight, lsp::Location, LanguageServerId),
  85}
  86
  87impl TriggerPoint {
  88    fn anchor(&self) -> &Anchor {
  89        match self {
  90            TriggerPoint::Text(anchor) => anchor,
  91            TriggerPoint::InlayHint(inlay_range, _, _) => &inlay_range.inlay_position,
  92        }
  93    }
  94}
  95
  96pub fn exclude_link_to_position(
  97    buffer: &Entity<language::Buffer>,
  98    current_position: &text::Anchor,
  99    location: &LocationLink,
 100    cx: &App,
 101) -> bool {
 102    // Exclude definition links that points back to cursor position.
 103    // (i.e., currently cursor upon definition).
 104    let snapshot = buffer.read(cx).snapshot();
 105    !(buffer == &location.target.buffer
 106        && current_position
 107            .bias_right(&snapshot)
 108            .cmp(&location.target.range.start, &snapshot)
 109            .is_ge()
 110        && current_position
 111            .cmp(&location.target.range.end, &snapshot)
 112            .is_le())
 113}
 114
 115impl Editor {
 116    pub(crate) fn update_hovered_link(
 117        &mut self,
 118        point_for_position: PointForPosition,
 119        snapshot: &EditorSnapshot,
 120        modifiers: Modifiers,
 121        window: &mut Window,
 122        cx: &mut Context<Self>,
 123    ) {
 124        let hovered_link_modifier = Editor::multi_cursor_modifier(false, &modifiers, cx);
 125        if !hovered_link_modifier || self.has_pending_selection() {
 126            self.hide_hovered_link(cx);
 127            return;
 128        }
 129
 130        match point_for_position.as_valid() {
 131            Some(point) => {
 132                let trigger_point = TriggerPoint::Text(
 133                    snapshot
 134                        .buffer_snapshot
 135                        .anchor_before(point.to_offset(&snapshot.display_snapshot, Bias::Left)),
 136                );
 137
 138                show_link_definition(modifiers.shift, self, trigger_point, snapshot, window, cx);
 139            }
 140            None => {
 141                update_inlay_link_and_hover_points(
 142                    snapshot,
 143                    point_for_position,
 144                    self,
 145                    hovered_link_modifier,
 146                    modifiers.shift,
 147                    window,
 148                    cx,
 149                );
 150            }
 151        }
 152    }
 153
 154    pub(crate) fn hide_hovered_link(&mut self, cx: &mut Context<Self>) {
 155        self.hovered_link_state.take();
 156        self.clear_highlights::<HoveredLinkState>(cx);
 157    }
 158
 159    pub(crate) fn handle_click_hovered_link(
 160        &mut self,
 161        point: PointForPosition,
 162        modifiers: Modifiers,
 163        window: &mut Window,
 164        cx: &mut Context<Editor>,
 165    ) {
 166        let reveal_task = self.cmd_click_reveal_task(point, modifiers, window, cx);
 167        cx.spawn_in(window, async move |editor, cx| {
 168            let definition_revealed = reveal_task.await.log_err().unwrap_or(Navigated::No);
 169            let find_references = editor
 170                .update_in(cx, |editor, window, cx| {
 171                    if definition_revealed == Navigated::Yes {
 172                        return None;
 173                    }
 174                    match EditorSettings::get_global(cx).go_to_definition_fallback {
 175                        GoToDefinitionFallback::None => None,
 176                        GoToDefinitionFallback::FindAllReferences => {
 177                            editor.find_all_references(&FindAllReferences, window, cx)
 178                        }
 179                    }
 180                })
 181                .ok()
 182                .flatten();
 183            if let Some(find_references) = find_references {
 184                find_references.await.log_err();
 185            }
 186        })
 187        .detach();
 188    }
 189
 190    pub fn scroll_hover(
 191        &mut self,
 192        amount: ScrollAmount,
 193        window: &mut Window,
 194        cx: &mut Context<Self>,
 195    ) -> bool {
 196        let selection = self.selections.newest_anchor().head();
 197        let snapshot = self.snapshot(window, cx);
 198
 199        if let Some(popover) = self.hover_state.info_popovers.iter().find(|popover| {
 200            popover
 201                .symbol_range
 202                .point_within_range(&TriggerPoint::Text(selection), &snapshot)
 203        }) {
 204            popover.scroll(amount, window, cx);
 205            true
 206        } else if let Some(context_menu) = self.context_menu.borrow_mut().as_mut() {
 207            context_menu.scroll_aside(amount, window, cx);
 208            true
 209        } else {
 210            false
 211        }
 212    }
 213
 214    fn cmd_click_reveal_task(
 215        &mut self,
 216        point: PointForPosition,
 217        modifiers: Modifiers,
 218        window: &mut Window,
 219        cx: &mut Context<Editor>,
 220    ) -> Task<anyhow::Result<Navigated>> {
 221        if let Some(hovered_link_state) = self.hovered_link_state.take() {
 222            self.hide_hovered_link(cx);
 223            if !hovered_link_state.links.is_empty() {
 224                if !self.focus_handle.is_focused(window) {
 225                    window.focus(&self.focus_handle);
 226                }
 227
 228                // exclude links pointing back to the current anchor
 229                let current_position = point
 230                    .next_valid
 231                    .to_point(&self.snapshot(window, cx).display_snapshot);
 232                let Some((buffer, anchor)) = self
 233                    .buffer()
 234                    .read(cx)
 235                    .text_anchor_for_position(current_position, cx)
 236                else {
 237                    return Task::ready(Ok(Navigated::No));
 238                };
 239                let links = hovered_link_state
 240                    .links
 241                    .into_iter()
 242                    .filter(|link| {
 243                        if let HoverLink::Text(location) = link {
 244                            exclude_link_to_position(&buffer, &anchor, location, cx)
 245                        } else {
 246                            true
 247                        }
 248                    })
 249                    .collect();
 250                let navigate_task =
 251                    self.navigate_to_hover_links(None, links, modifiers.alt, window, cx);
 252                self.select(SelectPhase::End, window, cx);
 253                return navigate_task;
 254            }
 255        }
 256
 257        // We don't have the correct kind of link cached, set the selection on
 258        // click and immediately trigger GoToDefinition.
 259        self.select(
 260            SelectPhase::Begin {
 261                position: point.next_valid,
 262                add: false,
 263                click_count: 1,
 264            },
 265            window,
 266            cx,
 267        );
 268
 269        let navigate_task = if point.as_valid().is_some() {
 270            match (modifiers.shift, modifiers.alt) {
 271                (true, true) => {
 272                    self.go_to_type_definition_split(&GoToTypeDefinitionSplit, window, cx)
 273                }
 274                (true, false) => self.go_to_type_definition(&GoToTypeDefinition, window, cx),
 275                (false, true) => self.go_to_definition_split(&GoToDefinitionSplit, window, cx),
 276                (false, false) => self.go_to_definition(&GoToDefinition, window, cx),
 277            }
 278        } else {
 279            Task::ready(Ok(Navigated::No))
 280        };
 281        self.select(SelectPhase::End, window, cx);
 282        navigate_task
 283    }
 284}
 285
 286pub fn update_inlay_link_and_hover_points(
 287    snapshot: &EditorSnapshot,
 288    point_for_position: PointForPosition,
 289    editor: &mut Editor,
 290    secondary_held: bool,
 291    shift_held: bool,
 292    window: &mut Window,
 293    cx: &mut Context<Editor>,
 294) {
 295    let hovered_offset = if point_for_position.column_overshoot_after_line_end == 0 {
 296        Some(snapshot.display_point_to_inlay_offset(point_for_position.exact_unclipped, Bias::Left))
 297    } else {
 298        None
 299    };
 300    let mut go_to_definition_updated = false;
 301    let mut hover_updated = false;
 302    if let Some(hovered_offset) = hovered_offset {
 303        let buffer_snapshot = editor.buffer().read(cx).snapshot(cx);
 304        let previous_valid_anchor =
 305            buffer_snapshot.anchor_before(point_for_position.previous_valid.to_point(snapshot));
 306        let next_valid_anchor =
 307            buffer_snapshot.anchor_after(point_for_position.next_valid.to_point(snapshot));
 308        if let Some(hovered_hint) = editor
 309            .visible_inlay_hints(cx)
 310            .into_iter()
 311            .skip_while(|hint| {
 312                hint.position
 313                    .cmp(&previous_valid_anchor, &buffer_snapshot)
 314                    .is_lt()
 315            })
 316            .take_while(|hint| {
 317                hint.position
 318                    .cmp(&next_valid_anchor, &buffer_snapshot)
 319                    .is_le()
 320            })
 321            .max_by_key(|hint| hint.id)
 322        {
 323            let inlay_hint_cache = editor.inlay_hint_cache();
 324            let excerpt_id = previous_valid_anchor.excerpt_id;
 325            if let Some(cached_hint) = inlay_hint_cache.hint_by_id(excerpt_id, hovered_hint.id) {
 326                match cached_hint.resolve_state {
 327                    ResolveState::CanResolve(_, _) => {
 328                        if let Some(buffer_id) = snapshot
 329                            .buffer_snapshot
 330                            .buffer_id_for_anchor(previous_valid_anchor)
 331                        {
 332                            inlay_hint_cache.spawn_hint_resolve(
 333                                buffer_id,
 334                                excerpt_id,
 335                                hovered_hint.id,
 336                                window,
 337                                cx,
 338                            );
 339                        }
 340                    }
 341                    ResolveState::Resolved => {
 342                        let mut extra_shift_left = 0;
 343                        let mut extra_shift_right = 0;
 344                        if cached_hint.padding_left {
 345                            extra_shift_left += 1;
 346                            extra_shift_right += 1;
 347                        }
 348                        if cached_hint.padding_right {
 349                            extra_shift_right += 1;
 350                        }
 351                        match cached_hint.label {
 352                            project::InlayHintLabel::String(_) => {
 353                                if let Some(tooltip) = cached_hint.tooltip {
 354                                    hover_popover::hover_at_inlay(
 355                                        editor,
 356                                        InlayHover {
 357                                            tooltip: match tooltip {
 358                                                InlayHintTooltip::String(text) => HoverBlock {
 359                                                    text,
 360                                                    kind: HoverBlockKind::PlainText,
 361                                                },
 362                                                InlayHintTooltip::MarkupContent(content) => {
 363                                                    HoverBlock {
 364                                                        text: content.value,
 365                                                        kind: content.kind,
 366                                                    }
 367                                                }
 368                                            },
 369                                            range: InlayHighlight {
 370                                                inlay: hovered_hint.id,
 371                                                inlay_position: hovered_hint.position,
 372                                                range: extra_shift_left
 373                                                    ..hovered_hint.text().len() + extra_shift_right,
 374                                            },
 375                                        },
 376                                        window,
 377                                        cx,
 378                                    );
 379                                    hover_updated = true;
 380                                }
 381                            }
 382                            project::InlayHintLabel::LabelParts(label_parts) => {
 383                                let hint_start =
 384                                    snapshot.anchor_to_inlay_offset(hovered_hint.position);
 385                                if let Some((hovered_hint_part, part_range)) =
 386                                    hover_popover::find_hovered_hint_part(
 387                                        label_parts,
 388                                        hint_start,
 389                                        hovered_offset,
 390                                    )
 391                                {
 392                                    let highlight_start =
 393                                        (part_range.start - hint_start).0 + extra_shift_left;
 394                                    let highlight_end =
 395                                        (part_range.end - hint_start).0 + extra_shift_right;
 396                                    let highlight = InlayHighlight {
 397                                        inlay: hovered_hint.id,
 398                                        inlay_position: hovered_hint.position,
 399                                        range: highlight_start..highlight_end,
 400                                    };
 401                                    if let Some(tooltip) = hovered_hint_part.tooltip {
 402                                        hover_popover::hover_at_inlay(
 403                                            editor,
 404                                            InlayHover {
 405                                                tooltip: match tooltip {
 406                                                    InlayHintLabelPartTooltip::String(text) => {
 407                                                        HoverBlock {
 408                                                            text,
 409                                                            kind: HoverBlockKind::PlainText,
 410                                                        }
 411                                                    }
 412                                                    InlayHintLabelPartTooltip::MarkupContent(
 413                                                        content,
 414                                                    ) => HoverBlock {
 415                                                        text: content.value,
 416                                                        kind: content.kind,
 417                                                    },
 418                                                },
 419                                                range: highlight.clone(),
 420                                            },
 421                                            window,
 422                                            cx,
 423                                        );
 424                                        hover_updated = true;
 425                                    }
 426                                    if let Some((language_server_id, location)) =
 427                                        hovered_hint_part.location
 428                                        && secondary_held
 429                                        && !editor.has_pending_nonempty_selection()
 430                                    {
 431                                        go_to_definition_updated = true;
 432                                        show_link_definition(
 433                                            shift_held,
 434                                            editor,
 435                                            TriggerPoint::InlayHint(
 436                                                highlight,
 437                                                location,
 438                                                language_server_id,
 439                                            ),
 440                                            snapshot,
 441                                            window,
 442                                            cx,
 443                                        );
 444                                    }
 445                                }
 446                            }
 447                        };
 448                    }
 449                    ResolveState::Resolving => {}
 450                }
 451            }
 452        }
 453    }
 454
 455    if !go_to_definition_updated {
 456        editor.hide_hovered_link(cx)
 457    }
 458    if !hover_updated {
 459        hover_popover::hover_at(editor, None, window, cx);
 460    }
 461}
 462
 463pub fn show_link_definition(
 464    shift_held: bool,
 465    editor: &mut Editor,
 466    trigger_point: TriggerPoint,
 467    snapshot: &EditorSnapshot,
 468    window: &mut Window,
 469    cx: &mut Context<Editor>,
 470) {
 471    let preferred_kind = match trigger_point {
 472        TriggerPoint::Text(_) if !shift_held => GotoDefinitionKind::Symbol,
 473        _ => GotoDefinitionKind::Type,
 474    };
 475
 476    let (mut hovered_link_state, is_cached) =
 477        if let Some(existing) = editor.hovered_link_state.take() {
 478            (existing, true)
 479        } else {
 480            (
 481                HoveredLinkState {
 482                    last_trigger_point: trigger_point.clone(),
 483                    symbol_range: None,
 484                    preferred_kind,
 485                    links: vec![],
 486                    task: None,
 487                },
 488                false,
 489            )
 490        };
 491
 492    if editor.pending_rename.is_some() {
 493        return;
 494    }
 495
 496    let trigger_anchor = trigger_point.anchor();
 497    let Some((buffer, buffer_position)) = editor
 498        .buffer
 499        .read(cx)
 500        .text_anchor_for_position(*trigger_anchor, cx)
 501    else {
 502        return;
 503    };
 504
 505    let Some((excerpt_id, _, _)) = editor
 506        .buffer()
 507        .read(cx)
 508        .excerpt_containing(*trigger_anchor, cx)
 509    else {
 510        return;
 511    };
 512
 513    let same_kind = hovered_link_state.preferred_kind == preferred_kind
 514        || hovered_link_state
 515            .links
 516            .first()
 517            .is_some_and(|d| matches!(d, HoverLink::Url(_)));
 518
 519    if same_kind {
 520        if is_cached && (hovered_link_state.last_trigger_point == trigger_point)
 521            || hovered_link_state
 522                .symbol_range
 523                .as_ref()
 524                .is_some_and(|symbol_range| {
 525                    symbol_range.point_within_range(&trigger_point, snapshot)
 526                })
 527        {
 528            editor.hovered_link_state = Some(hovered_link_state);
 529            return;
 530        }
 531    } else {
 532        editor.hide_hovered_link(cx)
 533    }
 534    let project = editor.project.clone();
 535    let provider = editor.semantics_provider.clone();
 536
 537    let snapshot = snapshot.buffer_snapshot.clone();
 538    hovered_link_state.task = Some(cx.spawn_in(window, async move |this, cx| {
 539        async move {
 540            let result = match &trigger_point {
 541                TriggerPoint::Text(_) => {
 542                    if let Some((url_range, url)) = find_url(&buffer, buffer_position, cx.clone()) {
 543                        this.read_with(cx, |_, _| {
 544                            let range = maybe!({
 545                                let start =
 546                                    snapshot.anchor_in_excerpt(excerpt_id, url_range.start)?;
 547                                let end = snapshot.anchor_in_excerpt(excerpt_id, url_range.end)?;
 548                                Some(RangeInEditor::Text(start..end))
 549                            });
 550                            (range, vec![HoverLink::Url(url)])
 551                        })
 552                        .ok()
 553                    } else if let Some((filename_range, filename)) =
 554                        find_file(&buffer, project.clone(), buffer_position, cx).await
 555                    {
 556                        let range = maybe!({
 557                            let start =
 558                                snapshot.anchor_in_excerpt(excerpt_id, filename_range.start)?;
 559                            let end = snapshot.anchor_in_excerpt(excerpt_id, filename_range.end)?;
 560                            Some(RangeInEditor::Text(start..end))
 561                        });
 562
 563                        Some((range, vec![HoverLink::File(filename)]))
 564                    } else if let Some(provider) = provider {
 565                        let task = cx.update(|_, cx| {
 566                            provider.definitions(&buffer, buffer_position, preferred_kind, cx)
 567                        })?;
 568                        if let Some(task) = task {
 569                            task.await.ok().flatten().map(|definition_result| {
 570                                (
 571                                    definition_result.iter().find_map(|link| {
 572                                        link.origin.as_ref().and_then(|origin| {
 573                                            let start = snapshot.anchor_in_excerpt(
 574                                                excerpt_id,
 575                                                origin.range.start,
 576                                            )?;
 577                                            let end = snapshot
 578                                                .anchor_in_excerpt(excerpt_id, origin.range.end)?;
 579                                            Some(RangeInEditor::Text(start..end))
 580                                        })
 581                                    }),
 582                                    definition_result.into_iter().map(HoverLink::Text).collect(),
 583                                )
 584                            })
 585                        } else {
 586                            None
 587                        }
 588                    } else {
 589                        None
 590                    }
 591                }
 592                TriggerPoint::InlayHint(highlight, lsp_location, server_id) => Some((
 593                    Some(RangeInEditor::Inlay(highlight.clone())),
 594                    vec![HoverLink::InlayHint(lsp_location.clone(), *server_id)],
 595                )),
 596            };
 597
 598            this.update(cx, |editor, cx| {
 599                // Clear any existing highlights
 600                editor.clear_highlights::<HoveredLinkState>(cx);
 601                let Some(hovered_link_state) = editor.hovered_link_state.as_mut() else {
 602                    editor.hide_hovered_link(cx);
 603                    return;
 604                };
 605                hovered_link_state.preferred_kind = preferred_kind;
 606                hovered_link_state.symbol_range = result
 607                    .as_ref()
 608                    .and_then(|(symbol_range, _)| symbol_range.clone());
 609
 610                if let Some((symbol_range, definitions)) = result {
 611                    hovered_link_state.links = definitions;
 612
 613                    let underline_hovered_link = !hovered_link_state.links.is_empty()
 614                        || hovered_link_state.symbol_range.is_some();
 615
 616                    if underline_hovered_link {
 617                        let style = gpui::HighlightStyle {
 618                            underline: Some(gpui::UnderlineStyle {
 619                                thickness: px(1.),
 620                                ..Default::default()
 621                            }),
 622                            color: Some(cx.theme().colors().link_text_hover),
 623                            ..Default::default()
 624                        };
 625                        let highlight_range =
 626                            symbol_range.unwrap_or_else(|| match &trigger_point {
 627                                TriggerPoint::Text(trigger_anchor) => {
 628                                    // If no symbol range returned from language server, use the surrounding word.
 629                                    let (offset_range, _) =
 630                                        snapshot.surrounding_word(*trigger_anchor, None);
 631                                    RangeInEditor::Text(
 632                                        snapshot.anchor_before(offset_range.start)
 633                                            ..snapshot.anchor_after(offset_range.end),
 634                                    )
 635                                }
 636                                TriggerPoint::InlayHint(highlight, _, _) => {
 637                                    RangeInEditor::Inlay(highlight.clone())
 638                                }
 639                            });
 640
 641                        match highlight_range {
 642                            RangeInEditor::Text(text_range) => editor
 643                                .highlight_text::<HoveredLinkState>(vec![text_range], style, cx),
 644                            RangeInEditor::Inlay(highlight) => editor
 645                                .highlight_inlays::<HoveredLinkState>(vec![highlight], style, cx),
 646                        }
 647                    }
 648                } else {
 649                    editor.hide_hovered_link(cx);
 650                }
 651            })?;
 652
 653            anyhow::Ok(())
 654        }
 655        .log_err()
 656        .await
 657    }));
 658
 659    editor.hovered_link_state = Some(hovered_link_state);
 660}
 661
 662pub(crate) fn find_url(
 663    buffer: &Entity<language::Buffer>,
 664    position: text::Anchor,
 665    cx: AsyncWindowContext,
 666) -> Option<(Range<text::Anchor>, String)> {
 667    const LIMIT: usize = 2048;
 668
 669    let snapshot = buffer.read_with(&cx, |buffer, _| buffer.snapshot()).ok()?;
 670
 671    let offset = position.to_offset(&snapshot);
 672    let mut token_start = offset;
 673    let mut token_end = offset;
 674    let mut found_start = false;
 675    let mut found_end = false;
 676
 677    for ch in snapshot.reversed_chars_at(offset).take(LIMIT) {
 678        if ch.is_whitespace() {
 679            found_start = true;
 680            break;
 681        }
 682        token_start -= ch.len_utf8();
 683    }
 684    // Check if we didn't find the starting whitespace or if we didn't reach the start of the buffer
 685    if !found_start && token_start != 0 {
 686        return None;
 687    }
 688
 689    for ch in snapshot
 690        .chars_at(offset)
 691        .take(LIMIT - (offset - token_start))
 692    {
 693        if ch.is_whitespace() {
 694            found_end = true;
 695            break;
 696        }
 697        token_end += ch.len_utf8();
 698    }
 699    // Check if we didn't find the ending whitespace or if we read more or equal than LIMIT
 700    // which at this point would happen only if we reached the end of buffer
 701    if !found_end && (token_end - token_start >= LIMIT) {
 702        return None;
 703    }
 704
 705    let mut finder = LinkFinder::new();
 706    finder.kinds(&[LinkKind::Url]);
 707    let input = snapshot
 708        .text_for_range(token_start..token_end)
 709        .collect::<String>();
 710
 711    let relative_offset = offset - token_start;
 712    for link in finder.links(&input) {
 713        if link.start() <= relative_offset && link.end() >= relative_offset {
 714            let range = snapshot.anchor_before(token_start + link.start())
 715                ..snapshot.anchor_after(token_start + link.end());
 716            return Some((range, link.as_str().to_string()));
 717        }
 718    }
 719    None
 720}
 721
 722pub(crate) fn find_url_from_range(
 723    buffer: &Entity<language::Buffer>,
 724    range: Range<text::Anchor>,
 725    cx: AsyncWindowContext,
 726) -> Option<String> {
 727    const LIMIT: usize = 2048;
 728
 729    let Ok(snapshot) = buffer.read_with(&cx, |buffer, _| buffer.snapshot()) else {
 730        return None;
 731    };
 732
 733    let start_offset = range.start.to_offset(&snapshot);
 734    let end_offset = range.end.to_offset(&snapshot);
 735
 736    let mut token_start = start_offset.min(end_offset);
 737    let mut token_end = start_offset.max(end_offset);
 738
 739    let range_len = token_end - token_start;
 740
 741    if range_len >= LIMIT {
 742        return None;
 743    }
 744
 745    // Skip leading whitespace
 746    for ch in snapshot.chars_at(token_start).take(range_len) {
 747        if !ch.is_whitespace() {
 748            break;
 749        }
 750        token_start += ch.len_utf8();
 751    }
 752
 753    // Skip trailing whitespace
 754    for ch in snapshot.reversed_chars_at(token_end).take(range_len) {
 755        if !ch.is_whitespace() {
 756            break;
 757        }
 758        token_end -= ch.len_utf8();
 759    }
 760
 761    if token_start >= token_end {
 762        return None;
 763    }
 764
 765    let text = snapshot
 766        .text_for_range(token_start..token_end)
 767        .collect::<String>();
 768
 769    let mut finder = LinkFinder::new();
 770    finder.kinds(&[LinkKind::Url]);
 771
 772    if let Some(link) = finder.links(&text).next()
 773        && link.start() == 0
 774        && link.end() == text.len()
 775    {
 776        return Some(link.as_str().to_string());
 777    }
 778
 779    None
 780}
 781
 782pub(crate) async fn find_file(
 783    buffer: &Entity<language::Buffer>,
 784    project: Option<Entity<Project>>,
 785    position: text::Anchor,
 786    cx: &mut AsyncWindowContext,
 787) -> Option<(Range<text::Anchor>, ResolvedPath)> {
 788    let project = project?;
 789    let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot()).ok()?;
 790    let scope = snapshot.language_scope_at(position);
 791    let (range, candidate_file_path) = surrounding_filename(snapshot, position)?;
 792
 793    async fn check_path(
 794        candidate_file_path: &str,
 795        project: &Entity<Project>,
 796        buffer: &Entity<language::Buffer>,
 797        cx: &mut AsyncWindowContext,
 798    ) -> Option<ResolvedPath> {
 799        project
 800            .update(cx, |project, cx| {
 801                project.resolve_path_in_buffer(candidate_file_path, buffer, cx)
 802            })
 803            .ok()?
 804            .await
 805            .filter(|s| s.is_file())
 806    }
 807
 808    if let Some(existing_path) = check_path(&candidate_file_path, &project, buffer, cx).await {
 809        return Some((range, existing_path));
 810    }
 811
 812    if let Some(scope) = scope {
 813        for suffix in scope.path_suffixes() {
 814            if candidate_file_path.ends_with(format!(".{suffix}").as_str()) {
 815                continue;
 816            }
 817
 818            let suffixed_candidate = format!("{candidate_file_path}.{suffix}");
 819            if let Some(existing_path) = check_path(&suffixed_candidate, &project, buffer, cx).await
 820            {
 821                return Some((range, existing_path));
 822            }
 823        }
 824    }
 825
 826    None
 827}
 828
 829fn surrounding_filename(
 830    snapshot: language::BufferSnapshot,
 831    position: text::Anchor,
 832) -> Option<(Range<text::Anchor>, String)> {
 833    const LIMIT: usize = 2048;
 834
 835    let offset = position.to_offset(&snapshot);
 836    let mut token_start = offset;
 837    let mut token_end = offset;
 838    let mut found_start = false;
 839    let mut found_end = false;
 840    let mut inside_quotes = false;
 841
 842    let mut filename = String::new();
 843
 844    let mut backwards = snapshot.reversed_chars_at(offset).take(LIMIT).peekable();
 845    while let Some(ch) = backwards.next() {
 846        // Escaped whitespace
 847        if ch.is_whitespace() && backwards.peek() == Some(&'\\') {
 848            filename.push(ch);
 849            token_start -= ch.len_utf8();
 850            backwards.next();
 851            token_start -= '\\'.len_utf8();
 852            continue;
 853        }
 854        if ch.is_whitespace() {
 855            found_start = true;
 856            break;
 857        }
 858        if (ch == '"' || ch == '\'') && !inside_quotes {
 859            found_start = true;
 860            inside_quotes = true;
 861            break;
 862        }
 863
 864        filename.push(ch);
 865        token_start -= ch.len_utf8();
 866    }
 867    if !found_start && token_start != 0 {
 868        return None;
 869    }
 870
 871    filename = filename.chars().rev().collect();
 872
 873    let mut forwards = snapshot
 874        .chars_at(offset)
 875        .take(LIMIT - (offset - token_start))
 876        .peekable();
 877    while let Some(ch) = forwards.next() {
 878        // Skip escaped whitespace
 879        if ch == '\\' && forwards.peek().is_some_and(|ch| ch.is_whitespace()) {
 880            token_end += ch.len_utf8();
 881            let whitespace = forwards.next().unwrap();
 882            token_end += whitespace.len_utf8();
 883            filename.push(whitespace);
 884            continue;
 885        }
 886
 887        if ch.is_whitespace() {
 888            found_end = true;
 889            break;
 890        }
 891        if ch == '"' || ch == '\'' {
 892            // If we're inside quotes, we stop when we come across the next quote
 893            if inside_quotes {
 894                found_end = true;
 895                break;
 896            } else {
 897                // Otherwise, we skip the quote
 898                inside_quotes = true;
 899                token_end += ch.len_utf8();
 900                continue;
 901            }
 902        }
 903        filename.push(ch);
 904        token_end += ch.len_utf8();
 905    }
 906
 907    if !found_end && (token_end - token_start >= LIMIT) {
 908        return None;
 909    }
 910
 911    if filename.is_empty() {
 912        return None;
 913    }
 914
 915    let range = snapshot.anchor_before(token_start)..snapshot.anchor_after(token_end);
 916
 917    Some((range, filename))
 918}
 919
 920#[cfg(test)]
 921mod tests {
 922    use super::*;
 923    use crate::{
 924        DisplayPoint,
 925        display_map::ToDisplayPoint,
 926        editor_tests::init_test,
 927        inlay_hint_cache::tests::{cached_hint_labels, visible_hint_labels},
 928        test::editor_lsp_test_context::EditorLspTestContext,
 929    };
 930    use futures::StreamExt;
 931    use gpui::Modifiers;
 932    use indoc::indoc;
 933    use lsp::request::{GotoDefinition, GotoTypeDefinition};
 934    use settings::InlayHintSettingsContent;
 935    use util::{assert_set_eq, path};
 936    use workspace::item::Item;
 937
 938    #[gpui::test]
 939    async fn test_hover_type_links(cx: &mut gpui::TestAppContext) {
 940        init_test(cx, |_| {});
 941
 942        let mut cx = EditorLspTestContext::new_rust(
 943            lsp::ServerCapabilities {
 944                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
 945                type_definition_provider: Some(lsp::TypeDefinitionProviderCapability::Simple(true)),
 946                ..Default::default()
 947            },
 948            cx,
 949        )
 950        .await;
 951
 952        cx.set_state(indoc! {"
 953            struct A;
 954            let vˇariable = A;
 955        "});
 956        let screen_coord = cx.editor(|editor, _, cx| editor.pixel_position_of_cursor(cx));
 957
 958        // Basic hold cmd+shift, expect highlight in region if response contains type definition
 959        let symbol_range = cx.lsp_range(indoc! {"
 960            struct A;
 961            let «variable» = A;
 962        "});
 963        let target_range = cx.lsp_range(indoc! {"
 964            struct «A»;
 965            let variable = A;
 966        "});
 967
 968        cx.run_until_parked();
 969
 970        let mut requests =
 971            cx.set_request_handler::<GotoTypeDefinition, _, _>(move |url, _, _| async move {
 972                Ok(Some(lsp::GotoTypeDefinitionResponse::Link(vec![
 973                    lsp::LocationLink {
 974                        origin_selection_range: Some(symbol_range),
 975                        target_uri: url.clone(),
 976                        target_range,
 977                        target_selection_range: target_range,
 978                    },
 979                ])))
 980            });
 981
 982        let modifiers = if cfg!(target_os = "macos") {
 983            Modifiers::command_shift()
 984        } else {
 985            Modifiers::control_shift()
 986        };
 987
 988        cx.simulate_mouse_move(screen_coord.unwrap(), None, modifiers);
 989
 990        requests.next().await;
 991        cx.run_until_parked();
 992        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
 993            struct A;
 994            let «variable» = A;
 995        "});
 996
 997        cx.simulate_modifiers_change(Modifiers::secondary_key());
 998        cx.run_until_parked();
 999        // Assert no link highlights
1000        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1001            struct A;
1002            let variable = A;
1003        "});
1004
1005        cx.simulate_click(screen_coord.unwrap(), modifiers);
1006
1007        cx.assert_editor_state(indoc! {"
1008            struct «Aˇ»;
1009            let variable = A;
1010        "});
1011    }
1012
1013    #[gpui::test]
1014    async fn test_hover_links(cx: &mut gpui::TestAppContext) {
1015        init_test(cx, |_| {});
1016
1017        let mut cx = EditorLspTestContext::new_rust(
1018            lsp::ServerCapabilities {
1019                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1020                definition_provider: Some(lsp::OneOf::Left(true)),
1021                ..Default::default()
1022            },
1023            cx,
1024        )
1025        .await;
1026
1027        cx.set_state(indoc! {"
1028                fn ˇtest() { do_work(); }
1029                fn do_work() { test(); }
1030            "});
1031
1032        // Basic hold cmd, expect highlight in region if response contains definition
1033        let hover_point = cx.pixel_position(indoc! {"
1034                fn test() { do_wˇork(); }
1035                fn do_work() { test(); }
1036            "});
1037        let symbol_range = cx.lsp_range(indoc! {"
1038                fn test() { «do_work»(); }
1039                fn do_work() { test(); }
1040            "});
1041        let target_range = cx.lsp_range(indoc! {"
1042                fn test() { do_work(); }
1043                fn «do_work»() { test(); }
1044            "});
1045
1046        let mut requests =
1047            cx.set_request_handler::<GotoDefinition, _, _>(move |url, _, _| async move {
1048                Ok(Some(lsp::GotoDefinitionResponse::Link(vec![
1049                    lsp::LocationLink {
1050                        origin_selection_range: Some(symbol_range),
1051                        target_uri: url.clone(),
1052                        target_range,
1053                        target_selection_range: target_range,
1054                    },
1055                ])))
1056            });
1057
1058        cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key());
1059        requests.next().await;
1060        cx.background_executor.run_until_parked();
1061        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1062                fn test() { «do_work»(); }
1063                fn do_work() { test(); }
1064            "});
1065
1066        // Unpress cmd causes highlight to go away
1067        cx.simulate_modifiers_change(Modifiers::none());
1068        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1069                fn test() { do_work(); }
1070                fn do_work() { test(); }
1071            "});
1072
1073        let mut requests =
1074            cx.set_request_handler::<GotoDefinition, _, _>(move |url, _, _| async move {
1075                Ok(Some(lsp::GotoDefinitionResponse::Link(vec![
1076                    lsp::LocationLink {
1077                        origin_selection_range: Some(symbol_range),
1078                        target_uri: url.clone(),
1079                        target_range,
1080                        target_selection_range: target_range,
1081                    },
1082                ])))
1083            });
1084
1085        cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key());
1086        requests.next().await;
1087        cx.background_executor.run_until_parked();
1088        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1089                fn test() { «do_work»(); }
1090                fn do_work() { test(); }
1091            "});
1092
1093        // Moving mouse to location with no response dismisses highlight
1094        let hover_point = cx.pixel_position(indoc! {"
1095                fˇn test() { do_work(); }
1096                fn do_work() { test(); }
1097            "});
1098        let mut requests =
1099            cx.lsp
1100                .set_request_handler::<GotoDefinition, _, _>(move |_, _| async move {
1101                    // No definitions returned
1102                    Ok(Some(lsp::GotoDefinitionResponse::Link(vec![])))
1103                });
1104        cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key());
1105
1106        requests.next().await;
1107        cx.background_executor.run_until_parked();
1108
1109        // Assert no link highlights
1110        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1111                fn test() { do_work(); }
1112                fn do_work() { test(); }
1113            "});
1114
1115        // // Move mouse without cmd and then pressing cmd triggers highlight
1116        let hover_point = cx.pixel_position(indoc! {"
1117                fn test() { do_work(); }
1118                fn do_work() { teˇst(); }
1119            "});
1120        cx.simulate_mouse_move(hover_point, None, Modifiers::none());
1121
1122        // Assert no link highlights
1123        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1124                fn test() { do_work(); }
1125                fn do_work() { test(); }
1126            "});
1127
1128        let symbol_range = cx.lsp_range(indoc! {"
1129                fn test() { do_work(); }
1130                fn do_work() { «test»(); }
1131            "});
1132        let target_range = cx.lsp_range(indoc! {"
1133                fn «test»() { do_work(); }
1134                fn do_work() { test(); }
1135            "});
1136
1137        let mut requests =
1138            cx.set_request_handler::<GotoDefinition, _, _>(move |url, _, _| async move {
1139                Ok(Some(lsp::GotoDefinitionResponse::Link(vec![
1140                    lsp::LocationLink {
1141                        origin_selection_range: Some(symbol_range),
1142                        target_uri: url,
1143                        target_range,
1144                        target_selection_range: target_range,
1145                    },
1146                ])))
1147            });
1148
1149        cx.simulate_modifiers_change(Modifiers::secondary_key());
1150
1151        requests.next().await;
1152        cx.background_executor.run_until_parked();
1153
1154        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1155                fn test() { do_work(); }
1156                fn do_work() { «test»(); }
1157            "});
1158
1159        cx.deactivate_window();
1160        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1161                fn test() { do_work(); }
1162                fn do_work() { test(); }
1163            "});
1164
1165        cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key());
1166        cx.background_executor.run_until_parked();
1167        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1168                fn test() { do_work(); }
1169                fn do_work() { «test»(); }
1170            "});
1171
1172        // Moving again within the same symbol range doesn't re-request
1173        let hover_point = cx.pixel_position(indoc! {"
1174                fn test() { do_work(); }
1175                fn do_work() { tesˇt(); }
1176            "});
1177        cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key());
1178        cx.background_executor.run_until_parked();
1179        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1180                fn test() { do_work(); }
1181                fn do_work() { «test»(); }
1182            "});
1183
1184        // Cmd click with existing definition doesn't re-request and dismisses highlight
1185        cx.simulate_click(hover_point, Modifiers::secondary_key());
1186        cx.lsp
1187            .set_request_handler::<GotoDefinition, _, _>(move |_, _| async move {
1188                // Empty definition response to make sure we aren't hitting the lsp and using
1189                // the cached location instead
1190                Ok(Some(lsp::GotoDefinitionResponse::Link(vec![])))
1191            });
1192        cx.background_executor.run_until_parked();
1193        cx.assert_editor_state(indoc! {"
1194                fn «testˇ»() { do_work(); }
1195                fn do_work() { test(); }
1196            "});
1197
1198        // Assert no link highlights after jump
1199        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1200                fn test() { do_work(); }
1201                fn do_work() { test(); }
1202            "});
1203
1204        // Cmd click without existing definition requests and jumps
1205        let hover_point = cx.pixel_position(indoc! {"
1206                fn test() { do_wˇork(); }
1207                fn do_work() { test(); }
1208            "});
1209        let target_range = cx.lsp_range(indoc! {"
1210                fn test() { do_work(); }
1211                fn «do_work»() { test(); }
1212            "});
1213
1214        let mut requests =
1215            cx.set_request_handler::<GotoDefinition, _, _>(move |url, _, _| async move {
1216                Ok(Some(lsp::GotoDefinitionResponse::Link(vec![
1217                    lsp::LocationLink {
1218                        origin_selection_range: None,
1219                        target_uri: url,
1220                        target_range,
1221                        target_selection_range: target_range,
1222                    },
1223                ])))
1224            });
1225        cx.simulate_click(hover_point, Modifiers::secondary_key());
1226        requests.next().await;
1227        cx.background_executor.run_until_parked();
1228        cx.assert_editor_state(indoc! {"
1229                fn test() { do_work(); }
1230                fn «do_workˇ»() { test(); }
1231            "});
1232
1233        // 1. We have a pending selection, mouse point is over a symbol that we have a response for, hitting cmd and nothing happens
1234        // 2. Selection is completed, hovering
1235        let hover_point = cx.pixel_position(indoc! {"
1236                fn test() { do_wˇork(); }
1237                fn do_work() { test(); }
1238            "});
1239        let target_range = cx.lsp_range(indoc! {"
1240                fn test() { do_work(); }
1241                fn «do_work»() { test(); }
1242            "});
1243        let mut requests =
1244            cx.set_request_handler::<GotoDefinition, _, _>(move |url, _, _| async move {
1245                Ok(Some(lsp::GotoDefinitionResponse::Link(vec![
1246                    lsp::LocationLink {
1247                        origin_selection_range: None,
1248                        target_uri: url,
1249                        target_range,
1250                        target_selection_range: target_range,
1251                    },
1252                ])))
1253            });
1254
1255        // create a pending selection
1256        let selection_range = cx.ranges(indoc! {"
1257                fn «test() { do_w»ork(); }
1258                fn do_work() { test(); }
1259            "})[0]
1260            .clone();
1261        cx.update_editor(|editor, window, cx| {
1262            let snapshot = editor.buffer().read(cx).snapshot(cx);
1263            let anchor_range = snapshot.anchor_before(selection_range.start)
1264                ..snapshot.anchor_after(selection_range.end);
1265            editor.change_selections(Default::default(), window, cx, |s| {
1266                s.set_pending_anchor_range(anchor_range, crate::SelectMode::Character)
1267            });
1268        });
1269        cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key());
1270        cx.background_executor.run_until_parked();
1271        assert!(requests.try_next().is_err());
1272        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1273                fn test() { do_work(); }
1274                fn do_work() { test(); }
1275            "});
1276        cx.background_executor.run_until_parked();
1277    }
1278
1279    #[gpui::test]
1280    async fn test_inlay_hover_links(cx: &mut gpui::TestAppContext) {
1281        init_test(cx, |settings| {
1282            settings.defaults.inlay_hints = Some(InlayHintSettingsContent {
1283                enabled: Some(true),
1284                show_value_hints: Some(false),
1285                edit_debounce_ms: Some(0),
1286                scroll_debounce_ms: Some(0),
1287                show_type_hints: Some(true),
1288                show_parameter_hints: Some(true),
1289                show_other_hints: Some(true),
1290                show_background: Some(false),
1291                toggle_on_modifiers_press: None,
1292            })
1293        });
1294
1295        let mut cx = EditorLspTestContext::new_rust(
1296            lsp::ServerCapabilities {
1297                inlay_hint_provider: Some(lsp::OneOf::Left(true)),
1298                ..Default::default()
1299            },
1300            cx,
1301        )
1302        .await;
1303        cx.set_state(indoc! {"
1304                struct TestStruct;
1305
1306                fn main() {
1307                    let variableˇ = TestStruct;
1308                }
1309            "});
1310        let hint_start_offset = cx.ranges(indoc! {"
1311                struct TestStruct;
1312
1313                fn main() {
1314                    let variableˇ = TestStruct;
1315                }
1316            "})[0]
1317            .start;
1318        let hint_position = cx.to_lsp(hint_start_offset);
1319        let target_range = cx.lsp_range(indoc! {"
1320                struct «TestStruct»;
1321
1322                fn main() {
1323                    let variable = TestStruct;
1324                }
1325            "});
1326
1327        let expected_uri = cx.buffer_lsp_url.clone();
1328        let hint_label = ": TestStruct";
1329        cx.lsp
1330            .set_request_handler::<lsp::request::InlayHintRequest, _, _>(move |params, _| {
1331                let expected_uri = expected_uri.clone();
1332                async move {
1333                    assert_eq!(params.text_document.uri, expected_uri);
1334                    Ok(Some(vec![lsp::InlayHint {
1335                        position: hint_position,
1336                        label: lsp::InlayHintLabel::LabelParts(vec![lsp::InlayHintLabelPart {
1337                            value: hint_label.to_string(),
1338                            location: Some(lsp::Location {
1339                                uri: params.text_document.uri,
1340                                range: target_range,
1341                            }),
1342                            ..Default::default()
1343                        }]),
1344                        kind: Some(lsp::InlayHintKind::TYPE),
1345                        text_edits: None,
1346                        tooltip: None,
1347                        padding_left: Some(false),
1348                        padding_right: Some(false),
1349                        data: None,
1350                    }]))
1351                }
1352            })
1353            .next()
1354            .await;
1355        cx.background_executor.run_until_parked();
1356        cx.update_editor(|editor, _window, cx| {
1357            let expected_layers = vec![hint_label.to_string()];
1358            assert_eq!(expected_layers, cached_hint_labels(editor));
1359            assert_eq!(expected_layers, visible_hint_labels(editor, cx));
1360        });
1361
1362        let inlay_range = cx
1363            .ranges(indoc! {"
1364                struct TestStruct;
1365
1366                fn main() {
1367                    let variable« »= TestStruct;
1368                }
1369            "})
1370            .first()
1371            .cloned()
1372            .unwrap();
1373        let midpoint = cx.update_editor(|editor, window, cx| {
1374            let snapshot = editor.snapshot(window, cx);
1375            let previous_valid = inlay_range.start.to_display_point(&snapshot);
1376            let next_valid = inlay_range.end.to_display_point(&snapshot);
1377            assert_eq!(previous_valid.row(), next_valid.row());
1378            assert!(previous_valid.column() < next_valid.column());
1379            DisplayPoint::new(
1380                previous_valid.row(),
1381                previous_valid.column() + (hint_label.len() / 2) as u32,
1382            )
1383        });
1384        // Press cmd to trigger highlight
1385        let hover_point = cx.pixel_position_for(midpoint);
1386        cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key());
1387        cx.background_executor.run_until_parked();
1388        cx.update_editor(|editor, window, cx| {
1389            let snapshot = editor.snapshot(window, cx);
1390            let actual_highlights = snapshot
1391                .inlay_highlights::<HoveredLinkState>()
1392                .into_iter()
1393                .flat_map(|highlights| highlights.values().map(|(_, highlight)| highlight))
1394                .collect::<Vec<_>>();
1395
1396            let buffer_snapshot = editor.buffer().update(cx, |buffer, cx| buffer.snapshot(cx));
1397            let expected_highlight = InlayHighlight {
1398                inlay: InlayId::Hint(0),
1399                inlay_position: buffer_snapshot.anchor_after(inlay_range.start),
1400                range: 0..hint_label.len(),
1401            };
1402            assert_set_eq!(actual_highlights, vec![&expected_highlight]);
1403        });
1404
1405        cx.simulate_mouse_move(hover_point, None, Modifiers::none());
1406        // Assert no link highlights
1407        cx.update_editor(|editor, window, cx| {
1408                let snapshot = editor.snapshot(window, cx);
1409                let actual_ranges = snapshot
1410                    .text_highlight_ranges::<HoveredLinkState>()
1411                    .map(|ranges| ranges.as_ref().clone().1)
1412                    .unwrap_or_default();
1413
1414                assert!(actual_ranges.is_empty(), "When no cmd is pressed, should have no hint label selected, but got: {actual_ranges:?}");
1415            });
1416
1417        cx.simulate_modifiers_change(Modifiers::secondary_key());
1418        cx.background_executor.run_until_parked();
1419        cx.simulate_click(hover_point, Modifiers::secondary_key());
1420        cx.background_executor.run_until_parked();
1421        cx.assert_editor_state(indoc! {"
1422                struct «TestStructˇ»;
1423
1424                fn main() {
1425                    let variable = TestStruct;
1426                }
1427            "});
1428    }
1429
1430    #[gpui::test]
1431    async fn test_urls(cx: &mut gpui::TestAppContext) {
1432        init_test(cx, |_| {});
1433        let mut cx = EditorLspTestContext::new_rust(
1434            lsp::ServerCapabilities {
1435                ..Default::default()
1436            },
1437            cx,
1438        )
1439        .await;
1440
1441        cx.set_state(indoc! {"
1442            Let's test a [complex](https://zed.dev/channel/had-(oops)) caseˇ.
1443        "});
1444
1445        let screen_coord = cx.pixel_position(indoc! {"
1446            Let's test a [complex](https://zed.dev/channel/had-(ˇoops)) case.
1447            "});
1448
1449        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1450        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1451            Let's test a [complex](«https://zed.dev/channel/had-(oops)ˇ») case.
1452        "});
1453
1454        cx.simulate_click(screen_coord, Modifiers::secondary_key());
1455        assert_eq!(
1456            cx.opened_url(),
1457            Some("https://zed.dev/channel/had-(oops)".into())
1458        );
1459    }
1460
1461    #[gpui::test]
1462    async fn test_urls_at_beginning_of_buffer(cx: &mut gpui::TestAppContext) {
1463        init_test(cx, |_| {});
1464        let mut cx = EditorLspTestContext::new_rust(
1465            lsp::ServerCapabilities {
1466                ..Default::default()
1467            },
1468            cx,
1469        )
1470        .await;
1471
1472        cx.set_state(indoc! {"https://zed.dev/releases is a cool ˇwebpage."});
1473
1474        let screen_coord =
1475            cx.pixel_position(indoc! {"https://zed.dev/relˇeases is a cool webpage."});
1476
1477        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1478        cx.assert_editor_text_highlights::<HoveredLinkState>(
1479            indoc! {"«https://zed.dev/releasesˇ» is a cool webpage."},
1480        );
1481
1482        cx.simulate_click(screen_coord, Modifiers::secondary_key());
1483        assert_eq!(cx.opened_url(), Some("https://zed.dev/releases".into()));
1484    }
1485
1486    #[gpui::test]
1487    async fn test_urls_at_end_of_buffer(cx: &mut gpui::TestAppContext) {
1488        init_test(cx, |_| {});
1489        let mut cx = EditorLspTestContext::new_rust(
1490            lsp::ServerCapabilities {
1491                ..Default::default()
1492            },
1493            cx,
1494        )
1495        .await;
1496
1497        cx.set_state(indoc! {"A cool ˇwebpage is https://zed.dev/releases"});
1498
1499        let screen_coord =
1500            cx.pixel_position(indoc! {"A cool webpage is https://zed.dev/releˇases"});
1501
1502        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1503        cx.assert_editor_text_highlights::<HoveredLinkState>(
1504            indoc! {"A cool webpage is «https://zed.dev/releasesˇ»"},
1505        );
1506
1507        cx.simulate_click(screen_coord, Modifiers::secondary_key());
1508        assert_eq!(cx.opened_url(), Some("https://zed.dev/releases".into()));
1509    }
1510
1511    #[gpui::test]
1512    async fn test_surrounding_filename(cx: &mut gpui::TestAppContext) {
1513        init_test(cx, |_| {});
1514        let mut cx = EditorLspTestContext::new_rust(
1515            lsp::ServerCapabilities {
1516                ..Default::default()
1517            },
1518            cx,
1519        )
1520        .await;
1521
1522        let test_cases = [
1523            ("file ˇ name", None),
1524            ("ˇfile name", Some("file")),
1525            ("file ˇname", Some("name")),
1526            ("fiˇle name", Some("file")),
1527            ("filenˇame", Some("filename")),
1528            // Absolute path
1529            ("foobar ˇ/home/user/f.txt", Some("/home/user/f.txt")),
1530            ("foobar /home/useˇr/f.txt", Some("/home/user/f.txt")),
1531            // Windows
1532            ("C:\\Useˇrs\\user\\f.txt", Some("C:\\Users\\user\\f.txt")),
1533            // Whitespace
1534            ("ˇfile\\ -\\ name.txt", Some("file - name.txt")),
1535            ("file\\ -\\ naˇme.txt", Some("file - name.txt")),
1536            // Tilde
1537            ("ˇ~/file.txt", Some("~/file.txt")),
1538            ("~/fiˇle.txt", Some("~/file.txt")),
1539            // Double quotes
1540            ("\"fˇile.txt\"", Some("file.txt")),
1541            ("ˇ\"file.txt\"", Some("file.txt")),
1542            ("ˇ\"fi\\ le.txt\"", Some("fi le.txt")),
1543            // Single quotes
1544            ("'fˇile.txt'", Some("file.txt")),
1545            ("ˇ'file.txt'", Some("file.txt")),
1546            ("ˇ'fi\\ le.txt'", Some("fi le.txt")),
1547            // Quoted multibyte characters
1548            (" ˇ\"常\"", Some("常")),
1549            (" \"ˇ常\"", Some("常")),
1550            ("ˇ\"常\"", Some("常")),
1551        ];
1552
1553        for (input, expected) in test_cases {
1554            cx.set_state(input);
1555
1556            let (position, snapshot) = cx.editor(|editor, _, cx| {
1557                let positions = editor.selections.newest_anchor().head().text_anchor;
1558                let snapshot = editor
1559                    .buffer()
1560                    .clone()
1561                    .read(cx)
1562                    .as_singleton()
1563                    .unwrap()
1564                    .read(cx)
1565                    .snapshot();
1566                (positions, snapshot)
1567            });
1568
1569            let result = surrounding_filename(snapshot, position);
1570
1571            if let Some(expected) = expected {
1572                assert!(result.is_some(), "Failed to find file path: {}", input);
1573                let (_, path) = result.unwrap();
1574                assert_eq!(&path, expected, "Incorrect file path for input: {}", input);
1575            } else {
1576                assert!(
1577                    result.is_none(),
1578                    "Expected no result, but got one: {:?}",
1579                    result
1580                );
1581            }
1582        }
1583    }
1584
1585    #[gpui::test]
1586    async fn test_hover_filenames(cx: &mut gpui::TestAppContext) {
1587        init_test(cx, |_| {});
1588        let mut cx = EditorLspTestContext::new_rust(
1589            lsp::ServerCapabilities {
1590                ..Default::default()
1591            },
1592            cx,
1593        )
1594        .await;
1595
1596        // Insert a new file
1597        let fs = cx.update_workspace(|workspace, _, cx| workspace.project().read(cx).fs().clone());
1598        fs.as_fake()
1599            .insert_file(
1600                path!("/root/dir/file2.rs"),
1601                "This is file2.rs".as_bytes().to_vec(),
1602            )
1603            .await;
1604
1605        #[cfg(not(target_os = "windows"))]
1606        cx.set_state(indoc! {"
1607            You can't go to a file that does_not_exist.txt.
1608            Go to file2.rs if you want.
1609            Or go to ../dir/file2.rs if you want.
1610            Or go to /root/dir/file2.rs if project is local.
1611            Or go to /root/dir/file2 if this is a Rust file.ˇ
1612            "});
1613        #[cfg(target_os = "windows")]
1614        cx.set_state(indoc! {"
1615            You can't go to a file that does_not_exist.txt.
1616            Go to file2.rs if you want.
1617            Or go to ../dir/file2.rs if you want.
1618            Or go to C:/root/dir/file2.rs if project is local.
1619            Or go to C:/root/dir/file2 if this is a Rust file.ˇ
1620        "});
1621
1622        // File does not exist
1623        #[cfg(not(target_os = "windows"))]
1624        let screen_coord = cx.pixel_position(indoc! {"
1625            You can't go to a file that dˇoes_not_exist.txt.
1626            Go to file2.rs if you want.
1627            Or go to ../dir/file2.rs if you want.
1628            Or go to /root/dir/file2.rs if project is local.
1629            Or go to /root/dir/file2 if this is a Rust file.
1630        "});
1631        #[cfg(target_os = "windows")]
1632        let screen_coord = cx.pixel_position(indoc! {"
1633            You can't go to a file that dˇoes_not_exist.txt.
1634            Go to file2.rs if you want.
1635            Or go to ../dir/file2.rs if you want.
1636            Or go to C:/root/dir/file2.rs if project is local.
1637            Or go to C:/root/dir/file2 if this is a Rust file.
1638        "});
1639        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1640        // No highlight
1641        cx.update_editor(|editor, window, cx| {
1642            assert!(
1643                editor
1644                    .snapshot(window, cx)
1645                    .text_highlight_ranges::<HoveredLinkState>()
1646                    .unwrap_or_default()
1647                    .1
1648                    .is_empty()
1649            );
1650        });
1651
1652        // Moving the mouse over a file that does exist should highlight it.
1653        #[cfg(not(target_os = "windows"))]
1654        let screen_coord = cx.pixel_position(indoc! {"
1655            You can't go to a file that does_not_exist.txt.
1656            Go to fˇile2.rs if you want.
1657            Or go to ../dir/file2.rs if you want.
1658            Or go to /root/dir/file2.rs if project is local.
1659            Or go to /root/dir/file2 if this is a Rust file.
1660        "});
1661        #[cfg(target_os = "windows")]
1662        let screen_coord = cx.pixel_position(indoc! {"
1663            You can't go to a file that does_not_exist.txt.
1664            Go to fˇile2.rs if you want.
1665            Or go to ../dir/file2.rs if you want.
1666            Or go to C:/root/dir/file2.rs if project is local.
1667            Or go to C:/root/dir/file2 if this is a Rust file.
1668        "});
1669
1670        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1671        #[cfg(not(target_os = "windows"))]
1672        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1673            You can't go to a file that does_not_exist.txt.
1674            Go to «file2.rsˇ» if you want.
1675            Or go to ../dir/file2.rs if you want.
1676            Or go to /root/dir/file2.rs if project is local.
1677            Or go to /root/dir/file2 if this is a Rust file.
1678        "});
1679        #[cfg(target_os = "windows")]
1680        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1681            You can't go to a file that does_not_exist.txt.
1682            Go to «file2.rsˇ» if you want.
1683            Or go to ../dir/file2.rs if you want.
1684            Or go to C:/root/dir/file2.rs if project is local.
1685            Or go to C:/root/dir/file2 if this is a Rust file.
1686        "});
1687
1688        // Moving the mouse over a relative path that does exist should highlight it
1689        #[cfg(not(target_os = "windows"))]
1690        let screen_coord = cx.pixel_position(indoc! {"
1691            You can't go to a file that does_not_exist.txt.
1692            Go to file2.rs if you want.
1693            Or go to ../dir/fˇile2.rs if you want.
1694            Or go to /root/dir/file2.rs if project is local.
1695            Or go to /root/dir/file2 if this is a Rust file.
1696        "});
1697        #[cfg(target_os = "windows")]
1698        let screen_coord = cx.pixel_position(indoc! {"
1699            You can't go to a file that does_not_exist.txt.
1700            Go to file2.rs if you want.
1701            Or go to ../dir/fˇile2.rs if you want.
1702            Or go to C:/root/dir/file2.rs if project is local.
1703            Or go to C:/root/dir/file2 if this is a Rust file.
1704        "});
1705
1706        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1707        #[cfg(not(target_os = "windows"))]
1708        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1709            You can't go to a file that does_not_exist.txt.
1710            Go to file2.rs if you want.
1711            Or go to «../dir/file2.rsˇ» if you want.
1712            Or go to /root/dir/file2.rs if project is local.
1713            Or go to /root/dir/file2 if this is a Rust file.
1714        "});
1715        #[cfg(target_os = "windows")]
1716        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1717            You can't go to a file that does_not_exist.txt.
1718            Go to file2.rs if you want.
1719            Or go to «../dir/file2.rsˇ» if you want.
1720            Or go to C:/root/dir/file2.rs if project is local.
1721            Or go to C:/root/dir/file2 if this is a Rust file.
1722        "});
1723
1724        // Moving the mouse over an absolute path that does exist should highlight it
1725        #[cfg(not(target_os = "windows"))]
1726        let screen_coord = cx.pixel_position(indoc! {"
1727            You can't go to a file that does_not_exist.txt.
1728            Go to file2.rs if you want.
1729            Or go to ../dir/file2.rs if you want.
1730            Or go to /root/diˇr/file2.rs if project is local.
1731            Or go to /root/dir/file2 if this is a Rust file.
1732        "});
1733
1734        #[cfg(target_os = "windows")]
1735        let screen_coord = cx.pixel_position(indoc! {"
1736            You can't go to a file that does_not_exist.txt.
1737            Go to file2.rs if you want.
1738            Or go to ../dir/file2.rs if you want.
1739            Or go to C:/root/diˇr/file2.rs if project is local.
1740            Or go to C:/root/dir/file2 if this is a Rust file.
1741        "});
1742
1743        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1744        #[cfg(not(target_os = "windows"))]
1745        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1746            You can't go to a file that does_not_exist.txt.
1747            Go to file2.rs if you want.
1748            Or go to ../dir/file2.rs if you want.
1749            Or go to «/root/dir/file2.rsˇ» if project is local.
1750            Or go to /root/dir/file2 if this is a Rust file.
1751        "});
1752        #[cfg(target_os = "windows")]
1753        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1754            You can't go to a file that does_not_exist.txt.
1755            Go to file2.rs if you want.
1756            Or go to ../dir/file2.rs if you want.
1757            Or go to «C:/root/dir/file2.rsˇ» if project is local.
1758            Or go to C:/root/dir/file2 if this is a Rust file.
1759        "});
1760
1761        // Moving the mouse over a path that exists, if we add the language-specific suffix, it should highlight it
1762        #[cfg(not(target_os = "windows"))]
1763        let screen_coord = cx.pixel_position(indoc! {"
1764            You can't go to a file that does_not_exist.txt.
1765            Go to file2.rs if you want.
1766            Or go to ../dir/file2.rs if you want.
1767            Or go to /root/dir/file2.rs if project is local.
1768            Or go to /root/diˇr/file2 if this is a Rust file.
1769        "});
1770        #[cfg(target_os = "windows")]
1771        let screen_coord = cx.pixel_position(indoc! {"
1772            You can't go to a file that does_not_exist.txt.
1773            Go to file2.rs if you want.
1774            Or go to ../dir/file2.rs if you want.
1775            Or go to C:/root/dir/file2.rs if project is local.
1776            Or go to C:/root/diˇr/file2 if this is a Rust file.
1777        "});
1778
1779        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1780        #[cfg(not(target_os = "windows"))]
1781        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1782            You can't go to a file that does_not_exist.txt.
1783            Go to file2.rs if you want.
1784            Or go to ../dir/file2.rs if you want.
1785            Or go to /root/dir/file2.rs if project is local.
1786            Or go to «/root/dir/file2ˇ» if this is a Rust file.
1787        "});
1788        #[cfg(target_os = "windows")]
1789        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
1790            You can't go to a file that does_not_exist.txt.
1791            Go to file2.rs if you want.
1792            Or go to ../dir/file2.rs if you want.
1793            Or go to C:/root/dir/file2.rs if project is local.
1794            Or go to «C:/root/dir/file2ˇ» if this is a Rust file.
1795        "});
1796
1797        cx.simulate_click(screen_coord, Modifiers::secondary_key());
1798
1799        cx.update_workspace(|workspace, _, cx| assert_eq!(workspace.items(cx).count(), 2));
1800        cx.update_workspace(|workspace, _, cx| {
1801            let active_editor = workspace.active_item_as::<Editor>(cx).unwrap();
1802
1803            let buffer = active_editor
1804                .read(cx)
1805                .buffer()
1806                .read(cx)
1807                .as_singleton()
1808                .unwrap();
1809
1810            let file = buffer.read(cx).file().unwrap();
1811            let file_path = file.as_local().unwrap().abs_path(cx);
1812
1813            assert_eq!(
1814                file_path,
1815                std::path::PathBuf::from(path!("/root/dir/file2.rs"))
1816            );
1817        });
1818    }
1819
1820    #[gpui::test]
1821    async fn test_hover_directories(cx: &mut gpui::TestAppContext) {
1822        init_test(cx, |_| {});
1823        let mut cx = EditorLspTestContext::new_rust(
1824            lsp::ServerCapabilities {
1825                ..Default::default()
1826            },
1827            cx,
1828        )
1829        .await;
1830
1831        // Insert a new file
1832        let fs = cx.update_workspace(|workspace, _, cx| workspace.project().read(cx).fs().clone());
1833        fs.as_fake()
1834            .insert_file("/root/dir/file2.rs", "This is file2.rs".as_bytes().to_vec())
1835            .await;
1836
1837        cx.set_state(indoc! {"
1838            You can't open ../diˇr because it's a directory.
1839        "});
1840
1841        // File does not exist
1842        let screen_coord = cx.pixel_position(indoc! {"
1843            You can't open ../diˇr because it's a directory.
1844        "});
1845        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1846
1847        // No highlight
1848        cx.update_editor(|editor, window, cx| {
1849            assert!(
1850                editor
1851                    .snapshot(window, cx)
1852                    .text_highlight_ranges::<HoveredLinkState>()
1853                    .unwrap_or_default()
1854                    .1
1855                    .is_empty()
1856            );
1857        });
1858
1859        // Does not open the directory
1860        cx.simulate_click(screen_coord, Modifiers::secondary_key());
1861        cx.update_workspace(|workspace, _, cx| assert_eq!(workspace.items(cx).count(), 1));
1862    }
1863
1864    #[gpui::test]
1865    async fn test_hover_unicode(cx: &mut gpui::TestAppContext) {
1866        init_test(cx, |_| {});
1867        let mut cx = EditorLspTestContext::new_rust(
1868            lsp::ServerCapabilities {
1869                ..Default::default()
1870            },
1871            cx,
1872        )
1873        .await;
1874
1875        cx.set_state(indoc! {"
1876            You can't open ˇ\"🤩\" because it's an emoji.
1877        "});
1878
1879        // File does not exist
1880        let screen_coord = cx.pixel_position(indoc! {"
1881            You can't open ˇ\"🤩\" because it's an emoji.
1882        "});
1883        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
1884
1885        // No highlight, does not panic...
1886        cx.update_editor(|editor, window, cx| {
1887            assert!(
1888                editor
1889                    .snapshot(window, cx)
1890                    .text_highlight_ranges::<HoveredLinkState>()
1891                    .unwrap_or_default()
1892                    .1
1893                    .is_empty()
1894            );
1895        });
1896
1897        // Does not open the directory
1898        cx.simulate_click(screen_coord, Modifiers::secondary_key());
1899        cx.update_workspace(|workspace, _, cx| assert_eq!(workspace.items(cx).count(), 1));
1900    }
1901}