use crate::{ Anchor, Editor, EditorSettings, EditorSnapshot, FindAllReferences, GoToDefinition, GoToTypeDefinition, GotoDefinitionKind, InlayId, Navigated, PointForPosition, SelectPhase, display_map::InlayOffset, editor_settings::GoToDefinitionFallback, hover_popover::{self, InlayHover}, scroll::ScrollAmount, }; use gpui::{App, AsyncWindowContext, Context, Entity, Modifiers, Task, Window, px}; use language::{Bias, ToOffset}; use linkify::{LinkFinder, LinkKind}; use lsp::LanguageServerId; use project::{ HoverBlock, HoverBlockKind, InlayHintLabelPartTooltip, InlayHintTooltip, LocationLink, Project, ResolveState, ResolvedPath, }; use settings::Settings; use std::ops::Range; use text; use theme::ActiveTheme as _; use util::{ResultExt, TryFutureExt as _, maybe}; #[derive(Debug)] pub struct HoveredLinkState { pub last_trigger_point: TriggerPoint, pub preferred_kind: GotoDefinitionKind, pub symbol_range: Option, pub links: Vec, pub task: Option>>, } #[derive(Debug, Eq, PartialEq, Clone)] pub enum RangeInEditor { Text(Range), Inlay(InlayHighlight), } impl RangeInEditor { pub fn as_text_range(&self) -> Option> { match self { Self::Text(range) => Some(range.clone()), Self::Inlay(_) => None, } } pub fn point_within_range( &self, trigger_point: &TriggerPoint, snapshot: &EditorSnapshot, ) -> bool { match (self, trigger_point) { (Self::Text(range), TriggerPoint::Text(point)) => { let point_after_start = range.start.cmp(point, &snapshot.buffer_snapshot).is_le(); point_after_start && range.end.cmp(point, &snapshot.buffer_snapshot).is_ge() } (Self::Inlay(highlight), TriggerPoint::InlayHint(point, _, _)) => { highlight.inlay == point.inlay && highlight.range.contains(&point.range.start) && highlight.range.contains(&point.range.end) } (Self::Inlay(_), TriggerPoint::Text(_)) | (Self::Text(_), TriggerPoint::InlayHint(_, _, _)) => false, } } } #[derive(Debug, Clone)] pub enum HoverLink { Url(String), File(ResolvedPath), Text(LocationLink), InlayHint(lsp::Location, LanguageServerId), } #[derive(Debug, Clone, PartialEq, Eq)] pub struct InlayHighlight { pub inlay: InlayId, pub inlay_position: Anchor, pub range: Range, } #[derive(Debug, Clone, PartialEq)] pub enum TriggerPoint { Text(Anchor), InlayHint(InlayHighlight, lsp::Location, LanguageServerId), } impl TriggerPoint { fn anchor(&self) -> &Anchor { match self { TriggerPoint::Text(anchor) => anchor, TriggerPoint::InlayHint(inlay_range, _, _) => &inlay_range.inlay_position, } } } pub fn exclude_link_to_position( buffer: &Entity, current_position: &text::Anchor, location: &LocationLink, cx: &App, ) -> bool { // Exclude definition links that points back to cursor position. // (i.e., currently cursor upon definition). let snapshot = buffer.read(cx).snapshot(); !(buffer == &location.target.buffer && current_position .bias_right(&snapshot) .cmp(&location.target.range.start, &snapshot) .is_ge() && current_position .cmp(&location.target.range.end, &snapshot) .is_le()) } impl Editor { pub(crate) fn update_hovered_link( &mut self, point_for_position: PointForPosition, snapshot: &EditorSnapshot, modifiers: Modifiers, window: &mut Window, cx: &mut Context, ) { let hovered_link_modifier = Editor::multi_cursor_modifier(false, &modifiers, cx); // When you're dragging to select, and you release the drag to create the selection, // if you happened to end over something hoverable (including an inlay hint), don't // have the hovered link appear. That would be annoying, because all you're trying // to do is to create a selection, not hover to see a hovered link. if self.has_pending_selection() { self.hide_hovered_link(cx); return; } match point_for_position.as_valid() { Some(point) => { // Hide the underline unless you're holding the modifier key on the keyboard // which will perform a goto definition. if !hovered_link_modifier { self.hide_hovered_link(cx); return; } let trigger_point = TriggerPoint::Text( snapshot .buffer_snapshot .anchor_before(point.to_offset(&snapshot.display_snapshot, Bias::Left)), ); show_link_definition(modifiers.shift, self, trigger_point, snapshot, window, cx); } None => { update_inlay_link_and_hover_points( snapshot, point_for_position, self, hovered_link_modifier, modifiers.shift, window, cx, ); } } } pub(crate) fn hide_hovered_link(&mut self, cx: &mut Context) { self.hovered_link_state.take(); self.clear_highlights::(cx); } pub(crate) fn handle_click_hovered_link( &mut self, point: PointForPosition, modifiers: Modifiers, window: &mut Window, cx: &mut Context, ) { let reveal_task = self.cmd_click_reveal_task(point, modifiers, window, cx); cx.spawn_in(window, async move |editor, cx| { let definition_revealed = reveal_task.await.log_err().unwrap_or(Navigated::No); let find_references = editor .update_in(cx, |editor, window, cx| { if definition_revealed == Navigated::Yes { return None; } match EditorSettings::get_global(cx).go_to_definition_fallback { GoToDefinitionFallback::None => None, GoToDefinitionFallback::FindAllReferences => { editor.find_all_references(&FindAllReferences, window, cx) } } }) .ok() .flatten(); if let Some(find_references) = find_references { find_references.await.log_err(); } }) .detach(); } pub fn scroll_hover( &mut self, amount: &ScrollAmount, window: &mut Window, cx: &mut Context, ) -> bool { let selection = self.selections.newest_anchor().head(); let snapshot = self.snapshot(window, cx); let Some(popover) = self.hover_state.info_popovers.iter().find(|popover| { popover .symbol_range .point_within_range(&TriggerPoint::Text(selection), &snapshot) }) else { return false; }; popover.scroll(amount, window, cx); true } fn cmd_click_reveal_task( &mut self, point: PointForPosition, modifiers: Modifiers, window: &mut Window, cx: &mut Context, ) -> Task> { if let Some(hovered_link_state) = self.hovered_link_state.take() { self.hide_hovered_link(cx); if !hovered_link_state.links.is_empty() { if !self.focus_handle.is_focused(window) { window.focus(&self.focus_handle); } // exclude links pointing back to the current anchor let current_position = point .next_valid .to_point(&self.snapshot(window, cx).display_snapshot); let Some((buffer, anchor)) = self .buffer() .read(cx) .text_anchor_for_position(current_position, cx) else { return Task::ready(Ok(Navigated::No)); }; let links = hovered_link_state .links .into_iter() .filter(|link| { if let HoverLink::Text(location) = link { exclude_link_to_position(&buffer, &anchor, location, cx) } else { true } }) .collect(); let navigate_task = self.navigate_to_hover_links(None, links, modifiers.alt, window, cx); self.select(SelectPhase::End, window, cx); return navigate_task; } } // We don't have the correct kind of link cached, set the selection on // click and immediately trigger GoToDefinition. self.select( SelectPhase::Begin { position: point.next_valid, add: false, click_count: 1, }, window, cx, ); let navigate_task = if point.as_valid().is_some() { if modifiers.shift { self.go_to_type_definition(&GoToTypeDefinition, window, cx) } else { self.go_to_definition(&GoToDefinition, window, cx) } } else { Task::ready(Ok(Navigated::No)) }; self.select(SelectPhase::End, window, cx); navigate_task } } pub fn update_inlay_link_and_hover_points( snapshot: &EditorSnapshot, point_for_position: PointForPosition, editor: &mut Editor, secondary_held: bool, shift_held: bool, window: &mut Window, cx: &mut Context, ) { let hovered_offset = if point_for_position.column_overshoot_after_line_end == 0 { Some(snapshot.display_point_to_inlay_offset(point_for_position.exact_unclipped, Bias::Left)) } else { None }; let mut go_to_definition_updated = false; let mut hover_updated = false; if let Some(hovered_offset) = hovered_offset { let buffer_snapshot = editor.buffer().read(cx).snapshot(cx); let previous_valid_anchor = buffer_snapshot.anchor_at( point_for_position.previous_valid.to_point(snapshot), Bias::Left, ); let next_valid_anchor = buffer_snapshot.anchor_at( point_for_position.next_valid.to_point(snapshot), Bias::Right, ); if let Some(hovered_hint) = editor .visible_inlay_hints(cx) .into_iter() .skip_while(|hint| { hint.position .cmp(&previous_valid_anchor, &buffer_snapshot) .is_lt() }) .take_while(|hint| { hint.position .cmp(&next_valid_anchor, &buffer_snapshot) .is_le() }) .max_by_key(|hint| hint.id) { let inlay_hint_cache = editor.inlay_hint_cache(); let excerpt_id = hovered_hint.position.excerpt_id; if let Some(cached_hint) = inlay_hint_cache.hint_by_id(excerpt_id, hovered_hint.id) { // Check if we should process this hint for hover match cached_hint.resolve_state { ResolveState::CanResolve(_, _) => { if let Some(buffer_id) = snapshot .buffer_snapshot .buffer_id_for_anchor(hovered_hint.position) { inlay_hint_cache.spawn_hint_resolve( buffer_id, excerpt_id, hovered_hint.id, window, cx, ); } } ResolveState::Resolved => { let mut extra_shift_left = 0; let mut extra_shift_right = 0; if cached_hint.padding_left { extra_shift_left += 1; extra_shift_right += 1; } if cached_hint.padding_right { extra_shift_right += 1; } match cached_hint.label { project::InlayHintLabel::String(_) => { if let Some(tooltip) = cached_hint.tooltip { hover_popover::hover_at_inlay( editor, InlayHover { tooltip: match tooltip { InlayHintTooltip::String(text) => HoverBlock { text, kind: HoverBlockKind::PlainText, }, InlayHintTooltip::MarkupContent(content) => { HoverBlock { text: content.value, kind: content.kind, } } }, range: InlayHighlight { inlay: hovered_hint.id, inlay_position: hovered_hint.position, range: extra_shift_left ..hovered_hint.text.len() + extra_shift_right, }, }, window, cx, ); hover_updated = true; } } project::InlayHintLabel::LabelParts(label_parts) => { // Find the first part with actual hover information (tooltip or location) let _hint_start = snapshot.anchor_to_inlay_offset(hovered_hint.position); let mut part_offset = 0; for part in label_parts { let part_len = part.value.chars().count(); if part.tooltip.is_some() || part.location.is_some() { // Found the meaningful part - show hover for it let highlight_start = part_offset + extra_shift_left; let highlight_end = part_offset + part_len + extra_shift_right; let highlight = InlayHighlight { inlay: hovered_hint.id, inlay_position: hovered_hint.position, range: highlight_start..highlight_end, }; if let Some(tooltip) = part.tooltip { hover_popover::hover_at_inlay( editor, InlayHover { tooltip: match tooltip { InlayHintLabelPartTooltip::String(text) => { HoverBlock { text, kind: HoverBlockKind::PlainText, } } InlayHintLabelPartTooltip::MarkupContent( content, ) => HoverBlock { text: content.value, kind: content.kind, }, }, range: highlight.clone(), }, window, cx, ); hover_updated = true; } if let Some((language_server_id, location)) = part.location.clone() { // When there's no tooltip but we have a location, perform a "Go to Definition" style operation let filename = location .uri .path() .split('/') .next_back() .unwrap_or("unknown") .to_string(); hover_popover::hover_at_inlay( editor, InlayHover { tooltip: HoverBlock { text: "Loading documentation..." .to_string(), kind: HoverBlockKind::PlainText, }, range: highlight.clone(), }, window, cx, ); hover_updated = true; // Now perform the "Go to Definition" flow to get hover documentation if let Some(project) = editor.project.clone() { let highlight = highlight.clone(); let hint_value = part.value.clone(); let location_uri = location.uri.clone(); cx.spawn_in(window, async move |editor, cx| { async move { // Small delay to show the loading message first cx.background_executor() .timer(std::time::Duration::from_millis(50)) .await; // Convert LSP URL to file path let file_path = location.uri.to_file_path() .map_err(|_| anyhow::anyhow!("Invalid file URL"))?; // Open the definition file let definition_buffer = project .update(cx, |project, cx| { project.open_local_buffer(file_path, cx) })? .await?; // Extract documentation directly from the source let documentation = definition_buffer.update(cx, |buffer, _| { let line_number = location.range.start.line as usize; // Get the text of the buffer let text = buffer.text(); let lines: Vec<&str> = text.lines().collect(); // Look backwards from the definition line to find doc comments let mut doc_lines = Vec::new(); let mut current_line = line_number.saturating_sub(1); // Skip any attributes like #[derive(...)] while current_line > 0 && lines.get(current_line).map_or(false, |line| { let trimmed = line.trim(); trimmed.starts_with("#[") || trimmed.is_empty() }) { current_line = current_line.saturating_sub(1); } // Collect doc comments while current_line > 0 { if let Some(line) = lines.get(current_line) { let trimmed = line.trim(); if trimmed.starts_with("///") { // Remove the /// and any leading space let doc_text = trimmed.strip_prefix("///").unwrap_or("") .strip_prefix(" ").unwrap_or_else(|| trimmed.strip_prefix("///").unwrap_or("")); doc_lines.push(doc_text.to_string()); } else if !trimmed.is_empty() { // Stop at the first non-doc, non-empty line break; } } current_line = current_line.saturating_sub(1); } // Reverse to get correct order doc_lines.reverse(); // Also get the actual definition line let definition = lines.get(line_number) .map(|s| s.trim().to_string()) .unwrap_or_else(|| hint_value.clone()); if doc_lines.is_empty() { None } else { let docs = doc_lines.join("\n"); Some((definition, docs)) } })?; if let Some((definition, docs)) = documentation { // Format as markdown with the definition as a code block let formatted_docs = format!("```rust\n{}\n```\n\n{}", definition, docs); editor.update_in(cx, |editor, window, cx| { hover_popover::hover_at_inlay( editor, InlayHover { tooltip: HoverBlock { text: formatted_docs, kind: HoverBlockKind::Markdown, }, range: highlight, }, window, cx, ); }).log_err(); } else { // Fallback to showing just the location info let fallback_text = format!( "{}\n\nDefined in {} at line {}", hint_value.trim(), filename, location.range.start.line + 1 ); editor.update_in(cx, |editor, window, cx| { hover_popover::hover_at_inlay( editor, InlayHover { tooltip: HoverBlock { text: fallback_text, kind: HoverBlockKind::PlainText, }, range: highlight, }, window, cx, ); }).log_err(); } anyhow::Ok(()) } .log_err() .await }).detach(); } } if let Some((language_server_id, location)) = &part.location { if secondary_held && !editor.has_pending_nonempty_selection() { go_to_definition_updated = true; show_link_definition( shift_held, editor, TriggerPoint::InlayHint( highlight, location.clone(), *language_server_id, ), snapshot, window, cx, ); } } break; } part_offset += part_len; } } }; } ResolveState::Resolving => {} }; } } } if !go_to_definition_updated { editor.hide_hovered_link(cx) } if !hover_updated { hover_popover::hover_at(editor, None, window, cx); } } pub fn show_link_definition( shift_held: bool, editor: &mut Editor, trigger_point: TriggerPoint, snapshot: &EditorSnapshot, window: &mut Window, cx: &mut Context, ) { let preferred_kind = match trigger_point { TriggerPoint::Text(_) if !shift_held => GotoDefinitionKind::Symbol, _ => GotoDefinitionKind::Type, }; let (mut hovered_link_state, is_cached) = if let Some(existing) = editor.hovered_link_state.take() { (existing, true) } else { ( HoveredLinkState { last_trigger_point: trigger_point.clone(), symbol_range: None, preferred_kind, links: vec![], task: None, }, false, ) }; if editor.pending_rename.is_some() { return; } let trigger_anchor = trigger_point.anchor(); let Some((buffer, buffer_position)) = editor .buffer .read(cx) .text_anchor_for_position(*trigger_anchor, cx) else { return; }; let Some((excerpt_id, _, _)) = editor .buffer() .read(cx) .excerpt_containing(*trigger_anchor, cx) else { return; }; let same_kind = hovered_link_state.preferred_kind == preferred_kind || hovered_link_state .links .first() .is_some_and(|d| matches!(d, HoverLink::Url(_))); if same_kind { if is_cached && (hovered_link_state.last_trigger_point == trigger_point) || hovered_link_state .symbol_range .as_ref() .is_some_and(|symbol_range| { symbol_range.point_within_range(&trigger_point, snapshot) }) { editor.hovered_link_state = Some(hovered_link_state); return; } } else { editor.hide_hovered_link(cx) } let project = editor.project.clone(); let provider = editor.semantics_provider.clone(); let snapshot = snapshot.buffer_snapshot.clone(); hovered_link_state.task = Some(cx.spawn_in(window, async move |this, cx| { async move { let result = match &trigger_point { TriggerPoint::Text(_) => { if let Some((url_range, url)) = find_url(&buffer, buffer_position, cx.clone()) { this.read_with(cx, |_, _| { let range = maybe!({ let start = snapshot.anchor_in_excerpt(excerpt_id, url_range.start)?; let end = snapshot.anchor_in_excerpt(excerpt_id, url_range.end)?; Some(RangeInEditor::Text(start..end)) }); (range, vec![HoverLink::Url(url)]) }) .ok() } else if let Some((filename_range, filename)) = find_file(&buffer, project.clone(), buffer_position, cx).await { let range = maybe!({ let start = snapshot.anchor_in_excerpt(excerpt_id, filename_range.start)?; let end = snapshot.anchor_in_excerpt(excerpt_id, filename_range.end)?; Some(RangeInEditor::Text(start..end)) }); Some((range, vec![HoverLink::File(filename)])) } else if let Some(provider) = provider { let task = cx.update(|_, cx| { provider.definitions(&buffer, buffer_position, preferred_kind, cx) })?; if let Some(task) = task { task.await.ok().flatten().map(|definition_result| { ( definition_result.iter().find_map(|link| { link.origin.as_ref().and_then(|origin| { let start = snapshot.anchor_in_excerpt( excerpt_id, origin.range.start, )?; let end = snapshot .anchor_in_excerpt(excerpt_id, origin.range.end)?; Some(RangeInEditor::Text(start..end)) }) }), definition_result.into_iter().map(HoverLink::Text).collect(), ) }) } else { None } } else { None } } TriggerPoint::InlayHint(highlight, lsp_location, server_id) => Some(( Some(RangeInEditor::Inlay(highlight.clone())), vec![HoverLink::InlayHint(lsp_location.clone(), *server_id)], )), }; this.update(cx, |editor, cx| { // Clear any existing highlights editor.clear_highlights::(cx); let Some(hovered_link_state) = editor.hovered_link_state.as_mut() else { editor.hide_hovered_link(cx); return; }; hovered_link_state.preferred_kind = preferred_kind; hovered_link_state.symbol_range = result .as_ref() .and_then(|(symbol_range, _)| symbol_range.clone()); if let Some((symbol_range, definitions)) = result { hovered_link_state.links = definitions; let underline_hovered_link = !hovered_link_state.links.is_empty() || hovered_link_state.symbol_range.is_some(); if underline_hovered_link { let style = gpui::HighlightStyle { underline: Some(gpui::UnderlineStyle { thickness: px(1.), ..Default::default() }), color: Some(cx.theme().colors().link_text_hover), ..Default::default() }; let highlight_range = symbol_range.unwrap_or_else(|| match &trigger_point { TriggerPoint::Text(trigger_anchor) => { // If no symbol range returned from language server, use the surrounding word. let (offset_range, _) = snapshot.surrounding_word(*trigger_anchor, false); RangeInEditor::Text( snapshot.anchor_before(offset_range.start) ..snapshot.anchor_after(offset_range.end), ) } TriggerPoint::InlayHint(highlight, _, _) => { RangeInEditor::Inlay(highlight.clone()) } }); match highlight_range { RangeInEditor::Text(text_range) => editor .highlight_text::(vec![text_range], style, cx), RangeInEditor::Inlay(highlight) => editor .highlight_inlays::(vec![highlight], style, cx), } } } else { editor.hide_hovered_link(cx); } })?; anyhow::Ok(()) } .log_err() .await })); editor.hovered_link_state = Some(hovered_link_state); } pub(crate) fn find_url( buffer: &Entity, position: text::Anchor, cx: AsyncWindowContext, ) -> Option<(Range, String)> { const LIMIT: usize = 2048; let Ok(snapshot) = buffer.read_with(&cx, |buffer, _| buffer.snapshot()) else { return None; }; let offset = position.to_offset(&snapshot); let mut token_start = offset; let mut token_end = offset; let mut found_start = false; let mut found_end = false; for ch in snapshot.reversed_chars_at(offset).take(LIMIT) { if ch.is_whitespace() { found_start = true; break; } token_start -= ch.len_utf8(); } // Check if we didn't find the starting whitespace or if we didn't reach the start of the buffer if !found_start && token_start != 0 { return None; } for ch in snapshot .chars_at(offset) .take(LIMIT - (offset - token_start)) { if ch.is_whitespace() { found_end = true; break; } token_end += ch.len_utf8(); } // Check if we didn't find the ending whitespace or if we read more or equal than LIMIT // which at this point would happen only if we reached the end of buffer if !found_end && (token_end - token_start >= LIMIT) { return None; } let mut finder = LinkFinder::new(); finder.kinds(&[LinkKind::Url]); let input = snapshot .text_for_range(token_start..token_end) .collect::(); let relative_offset = offset - token_start; for link in finder.links(&input) { if link.start() <= relative_offset && link.end() >= relative_offset { let range = snapshot.anchor_before(token_start + link.start()) ..snapshot.anchor_after(token_start + link.end()); return Some((range, link.as_str().to_string())); } } None } pub(crate) fn find_url_from_range( buffer: &Entity, range: Range, cx: AsyncWindowContext, ) -> Option { const LIMIT: usize = 2048; let Ok(snapshot) = buffer.read_with(&cx, |buffer, _| buffer.snapshot()) else { return None; }; let start_offset = range.start.to_offset(&snapshot); let end_offset = range.end.to_offset(&snapshot); let mut token_start = start_offset.min(end_offset); let mut token_end = start_offset.max(end_offset); let range_len = token_end - token_start; if range_len >= LIMIT { return None; } // Skip leading whitespace for ch in snapshot.chars_at(token_start).take(range_len) { if !ch.is_whitespace() { break; } token_start += ch.len_utf8(); } // Skip trailing whitespace for ch in snapshot.reversed_chars_at(token_end).take(range_len) { if !ch.is_whitespace() { break; } token_end -= ch.len_utf8(); } if token_start >= token_end { return None; } let text = snapshot .text_for_range(token_start..token_end) .collect::(); let mut finder = LinkFinder::new(); finder.kinds(&[LinkKind::Url]); if let Some(link) = finder.links(&text).next() && link.start() == 0 && link.end() == text.len() { return Some(link.as_str().to_string()); } None } pub(crate) async fn find_file( buffer: &Entity, project: Option>, position: text::Anchor, cx: &mut AsyncWindowContext, ) -> Option<(Range, ResolvedPath)> { let project = project?; let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot()).ok()?; let scope = snapshot.language_scope_at(position); let (range, candidate_file_path) = surrounding_filename(snapshot, position)?; async fn check_path( candidate_file_path: &str, project: &Entity, buffer: &Entity, cx: &mut AsyncWindowContext, ) -> Option { project .update(cx, |project, cx| { project.resolve_path_in_buffer(candidate_file_path, buffer, cx) }) .ok()? .await .filter(|s| s.is_file()) } if let Some(existing_path) = check_path(&candidate_file_path, &project, buffer, cx).await { return Some((range, existing_path)); } if let Some(scope) = scope { for suffix in scope.path_suffixes() { if candidate_file_path.ends_with(format!(".{suffix}").as_str()) { continue; } let suffixed_candidate = format!("{candidate_file_path}.{suffix}"); if let Some(existing_path) = check_path(&suffixed_candidate, &project, buffer, cx).await { return Some((range, existing_path)); } } } None } fn surrounding_filename( snapshot: language::BufferSnapshot, position: text::Anchor, ) -> Option<(Range, String)> { const LIMIT: usize = 2048; let offset = position.to_offset(&snapshot); let mut token_start = offset; let mut token_end = offset; let mut found_start = false; let mut found_end = false; let mut inside_quotes = false; let mut filename = String::new(); let mut backwards = snapshot.reversed_chars_at(offset).take(LIMIT).peekable(); while let Some(ch) = backwards.next() { // Escaped whitespace if ch.is_whitespace() && backwards.peek() == Some(&'\\') { filename.push(ch); token_start -= ch.len_utf8(); backwards.next(); token_start -= '\\'.len_utf8(); continue; } if ch.is_whitespace() { found_start = true; break; } if (ch == '"' || ch == '\'') && !inside_quotes { found_start = true; inside_quotes = true; break; } filename.push(ch); token_start -= ch.len_utf8(); } if !found_start && token_start != 0 { return None; } filename = filename.chars().rev().collect(); let mut forwards = snapshot .chars_at(offset) .take(LIMIT - (offset - token_start)) .peekable(); while let Some(ch) = forwards.next() { // Skip escaped whitespace if ch == '\\' && forwards.peek().is_some_and(|ch| ch.is_whitespace()) { token_end += ch.len_utf8(); let whitespace = forwards.next().unwrap(); token_end += whitespace.len_utf8(); filename.push(whitespace); continue; } if ch.is_whitespace() { found_end = true; break; } if ch == '"' || ch == '\'' { // If we're inside quotes, we stop when we come across the next quote if inside_quotes { found_end = true; break; } else { // Otherwise, we skip the quote inside_quotes = true; continue; } } filename.push(ch); token_end += ch.len_utf8(); } if !found_end && (token_end - token_start >= LIMIT) { return None; } if filename.is_empty() { return None; } let range = snapshot.anchor_before(token_start)..snapshot.anchor_after(token_end); Some((range, filename)) } #[cfg(test)] mod tests { use super::*; use crate::{ DisplayPoint, display_map::ToDisplayPoint, editor_tests::init_test, inlay_hint_cache::tests::{cached_hint_labels, visible_hint_labels}, test::editor_lsp_test_context::EditorLspTestContext, }; use futures::StreamExt; use gpui::Modifiers; use indoc::indoc; use language::language_settings::InlayHintSettings; use lsp::request::{GotoDefinition, GotoTypeDefinition}; use util::{assert_set_eq, path}; use workspace::item::Item; #[gpui::test] async fn test_hover_type_links(cx: &mut gpui::TestAppContext) { init_test(cx, |_| {}); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { hover_provider: Some(lsp::HoverProviderCapability::Simple(true)), type_definition_provider: Some(lsp::TypeDefinitionProviderCapability::Simple(true)), ..Default::default() }, cx, ) .await; cx.set_state(indoc! {" struct A; let vˇariable = A; "}); let screen_coord = cx.editor(|editor, _, cx| editor.pixel_position_of_cursor(cx)); // Basic hold cmd+shift, expect highlight in region if response contains type definition let symbol_range = cx.lsp_range(indoc! {" struct A; let «variable» = A; "}); let target_range = cx.lsp_range(indoc! {" struct «A»; let variable = A; "}); cx.run_until_parked(); let mut requests = cx.set_request_handler::(move |url, _, _| async move { Ok(Some(lsp::GotoTypeDefinitionResponse::Link(vec![ lsp::LocationLink { origin_selection_range: Some(symbol_range), target_uri: url.clone(), target_range, target_selection_range: target_range, }, ]))) }); let modifiers = if cfg!(target_os = "macos") { Modifiers::command_shift() } else { Modifiers::control_shift() }; cx.simulate_mouse_move(screen_coord.unwrap(), None, modifiers); requests.next().await; cx.run_until_parked(); cx.assert_editor_text_highlights::(indoc! {" struct A; let «variable» = A; "}); cx.simulate_modifiers_change(Modifiers::secondary_key()); cx.run_until_parked(); // Assert no link highlights cx.assert_editor_text_highlights::(indoc! {" struct A; let variable = A; "}); cx.simulate_click(screen_coord.unwrap(), modifiers); cx.assert_editor_state(indoc! {" struct «Aˇ»; let variable = A; "}); } #[gpui::test] async fn test_hover_links(cx: &mut gpui::TestAppContext) { init_test(cx, |_| {}); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { hover_provider: Some(lsp::HoverProviderCapability::Simple(true)), definition_provider: Some(lsp::OneOf::Left(true)), ..Default::default() }, cx, ) .await; cx.set_state(indoc! {" fn ˇtest() { do_work(); } fn do_work() { test(); } "}); // Basic hold cmd, expect highlight in region if response contains definition let hover_point = cx.pixel_position(indoc! {" fn test() { do_wˇork(); } fn do_work() { test(); } "}); let symbol_range = cx.lsp_range(indoc! {" fn test() { «do_work»(); } fn do_work() { test(); } "}); let target_range = cx.lsp_range(indoc! {" fn test() { do_work(); } fn «do_work»() { test(); } "}); let mut requests = cx.set_request_handler::(move |url, _, _| async move { Ok(Some(lsp::GotoDefinitionResponse::Link(vec![ lsp::LocationLink { origin_selection_range: Some(symbol_range), target_uri: url.clone(), target_range, target_selection_range: target_range, }, ]))) }); cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key()); requests.next().await; cx.background_executor.run_until_parked(); cx.assert_editor_text_highlights::(indoc! {" fn test() { «do_work»(); } fn do_work() { test(); } "}); // Unpress cmd causes highlight to go away cx.simulate_modifiers_change(Modifiers::none()); cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { test(); } "}); let mut requests = cx.set_request_handler::(move |url, _, _| async move { Ok(Some(lsp::GotoDefinitionResponse::Link(vec![ lsp::LocationLink { origin_selection_range: Some(symbol_range), target_uri: url.clone(), target_range, target_selection_range: target_range, }, ]))) }); cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key()); requests.next().await; cx.background_executor.run_until_parked(); cx.assert_editor_text_highlights::(indoc! {" fn test() { «do_work»(); } fn do_work() { test(); } "}); // Moving mouse to location with no response dismisses highlight let hover_point = cx.pixel_position(indoc! {" fˇn test() { do_work(); } fn do_work() { test(); } "}); let mut requests = cx.lsp .set_request_handler::(move |_, _| async move { // No definitions returned Ok(Some(lsp::GotoDefinitionResponse::Link(vec![]))) }); cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key()); requests.next().await; cx.background_executor.run_until_parked(); // Assert no link highlights cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { test(); } "}); // // Move mouse without cmd and then pressing cmd triggers highlight let hover_point = cx.pixel_position(indoc! {" fn test() { do_work(); } fn do_work() { teˇst(); } "}); cx.simulate_mouse_move(hover_point, None, Modifiers::none()); // Assert no link highlights cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { test(); } "}); let symbol_range = cx.lsp_range(indoc! {" fn test() { do_work(); } fn do_work() { «test»(); } "}); let target_range = cx.lsp_range(indoc! {" fn «test»() { do_work(); } fn do_work() { test(); } "}); let mut requests = cx.set_request_handler::(move |url, _, _| async move { Ok(Some(lsp::GotoDefinitionResponse::Link(vec![ lsp::LocationLink { origin_selection_range: Some(symbol_range), target_uri: url, target_range, target_selection_range: target_range, }, ]))) }); cx.simulate_modifiers_change(Modifiers::secondary_key()); requests.next().await; cx.background_executor.run_until_parked(); cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { «test»(); } "}); cx.deactivate_window(); cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { test(); } "}); cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key()); cx.background_executor.run_until_parked(); cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { «test»(); } "}); // Moving again within the same symbol range doesn't re-request let hover_point = cx.pixel_position(indoc! {" fn test() { do_work(); } fn do_work() { tesˇt(); } "}); cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key()); cx.background_executor.run_until_parked(); cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { «test»(); } "}); // Cmd click with existing definition doesn't re-request and dismisses highlight cx.simulate_click(hover_point, Modifiers::secondary_key()); cx.lsp .set_request_handler::(move |_, _| async move { // Empty definition response to make sure we aren't hitting the lsp and using // the cached location instead Ok(Some(lsp::GotoDefinitionResponse::Link(vec![]))) }); cx.background_executor.run_until_parked(); cx.assert_editor_state(indoc! {" fn «testˇ»() { do_work(); } fn do_work() { test(); } "}); // Assert no link highlights after jump cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { test(); } "}); // Cmd click without existing definition requests and jumps let hover_point = cx.pixel_position(indoc! {" fn test() { do_wˇork(); } fn do_work() { test(); } "}); let target_range = cx.lsp_range(indoc! {" fn test() { do_work(); } fn «do_work»() { test(); } "}); let mut requests = cx.set_request_handler::(move |url, _, _| async move { Ok(Some(lsp::GotoDefinitionResponse::Link(vec![ lsp::LocationLink { origin_selection_range: None, target_uri: url, target_range, target_selection_range: target_range, }, ]))) }); cx.simulate_click(hover_point, Modifiers::secondary_key()); requests.next().await; cx.background_executor.run_until_parked(); cx.assert_editor_state(indoc! {" fn test() { do_work(); } fn «do_workˇ»() { test(); } "}); // 1. We have a pending selection, mouse point is over a symbol that we have a response for, hitting cmd and nothing happens // 2. Selection is completed, hovering let hover_point = cx.pixel_position(indoc! {" fn test() { do_wˇork(); } fn do_work() { test(); } "}); let target_range = cx.lsp_range(indoc! {" fn test() { do_work(); } fn «do_work»() { test(); } "}); let mut requests = cx.set_request_handler::(move |url, _, _| async move { Ok(Some(lsp::GotoDefinitionResponse::Link(vec![ lsp::LocationLink { origin_selection_range: None, target_uri: url, target_range, target_selection_range: target_range, }, ]))) }); // create a pending selection let selection_range = cx.ranges(indoc! {" fn «test() { do_w»ork(); } fn do_work() { test(); } "})[0] .clone(); cx.update_editor(|editor, window, cx| { let snapshot = editor.buffer().read(cx).snapshot(cx); let anchor_range = snapshot.anchor_before(selection_range.start) ..snapshot.anchor_after(selection_range.end); editor.change_selections(Default::default(), window, cx, |s| { s.set_pending_anchor_range(anchor_range, crate::SelectMode::Character) }); }); cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key()); cx.background_executor.run_until_parked(); assert!(requests.try_next().is_err()); cx.assert_editor_text_highlights::(indoc! {" fn test() { do_work(); } fn do_work() { test(); } "}); cx.background_executor.run_until_parked(); } #[gpui::test] async fn test_inlay_hover_links(cx: &mut gpui::TestAppContext) { init_test(cx, |settings| { settings.defaults.inlay_hints = Some(InlayHintSettings { enabled: true, show_value_hints: false, edit_debounce_ms: 0, scroll_debounce_ms: 0, show_type_hints: true, show_parameter_hints: true, show_other_hints: true, show_background: false, toggle_on_modifiers_press: None, }) }); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { inlay_hint_provider: Some(lsp::OneOf::Left(true)), ..Default::default() }, cx, ) .await; cx.set_state(indoc! {" struct TestStruct; fn main() { let variableˇ = TestStruct; } "}); let hint_start_offset = cx.ranges(indoc! {" struct TestStruct; fn main() { let variableˇ = TestStruct; } "})[0] .start; let hint_position = cx.to_lsp(hint_start_offset); let target_range = cx.lsp_range(indoc! {" struct «TestStruct»; fn main() { let variable = TestStruct; } "}); let expected_uri = cx.buffer_lsp_url.clone(); let hint_label = ": TestStruct"; cx.lsp .set_request_handler::(move |params, _| { let expected_uri = expected_uri.clone(); async move { assert_eq!(params.text_document.uri, expected_uri); Ok(Some(vec![lsp::InlayHint { position: hint_position, label: lsp::InlayHintLabel::LabelParts(vec![lsp::InlayHintLabelPart { value: hint_label.to_string(), location: Some(lsp::Location { uri: params.text_document.uri, range: target_range, }), ..Default::default() }]), kind: Some(lsp::InlayHintKind::TYPE), text_edits: None, tooltip: None, padding_left: Some(false), padding_right: Some(false), data: None, }])) } }) .next() .await; cx.background_executor.run_until_parked(); cx.update_editor(|editor, _window, cx| { let expected_layers = vec![hint_label.to_string()]; assert_eq!(expected_layers, cached_hint_labels(editor)); assert_eq!(expected_layers, visible_hint_labels(editor, cx)); }); let inlay_range = cx .ranges(indoc! {" struct TestStruct; fn main() { let variable« »= TestStruct; } "}) .first() .cloned() .unwrap(); let midpoint = cx.update_editor(|editor, window, cx| { let snapshot = editor.snapshot(window, cx); let previous_valid = inlay_range.start.to_display_point(&snapshot); let next_valid = inlay_range.end.to_display_point(&snapshot); assert_eq!(previous_valid.row(), next_valid.row()); assert!(previous_valid.column() < next_valid.column()); DisplayPoint::new( previous_valid.row(), previous_valid.column() + (hint_label.len() / 2) as u32, ) }); // Press cmd to trigger highlight let hover_point = cx.pixel_position_for(midpoint); cx.simulate_mouse_move(hover_point, None, Modifiers::secondary_key()); cx.background_executor.run_until_parked(); cx.update_editor(|editor, window, cx| { let snapshot = editor.snapshot(window, cx); let actual_highlights = snapshot .inlay_highlights::() .into_iter() .flat_map(|highlights| highlights.values().map(|(_, highlight)| highlight)) .collect::>(); let buffer_snapshot = editor.buffer().update(cx, |buffer, cx| buffer.snapshot(cx)); let expected_highlight = InlayHighlight { inlay: InlayId::Hint(0), inlay_position: buffer_snapshot.anchor_at(inlay_range.start, Bias::Right), range: 0..hint_label.len(), }; assert_set_eq!(actual_highlights, vec![&expected_highlight]); }); cx.simulate_mouse_move(hover_point, None, Modifiers::none()); // Assert no link highlights cx.update_editor(|editor, window, cx| { let snapshot = editor.snapshot(window, cx); let actual_ranges = snapshot .text_highlight_ranges::() .map(|ranges| ranges.as_ref().clone().1) .unwrap_or_default(); assert!(actual_ranges.is_empty(), "When no cmd is pressed, should have no hint label selected, but got: {actual_ranges:?}"); }); cx.simulate_modifiers_change(Modifiers::secondary_key()); cx.background_executor.run_until_parked(); cx.simulate_click(hover_point, Modifiers::secondary_key()); cx.background_executor.run_until_parked(); cx.assert_editor_state(indoc! {" struct «TestStructˇ»; fn main() { let variable = TestStruct; } "}); } #[gpui::test] async fn test_urls(cx: &mut gpui::TestAppContext) { init_test(cx, |_| {}); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { ..Default::default() }, cx, ) .await; cx.set_state(indoc! {" Let's test a [complex](https://zed.dev/channel/had-(oops)) caseˇ. "}); let screen_coord = cx.pixel_position(indoc! {" Let's test a [complex](https://zed.dev/channel/had-(ˇoops)) case. "}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); cx.assert_editor_text_highlights::(indoc! {" Let's test a [complex](«https://zed.dev/channel/had-(oops)ˇ») case. "}); cx.simulate_click(screen_coord, Modifiers::secondary_key()); assert_eq!( cx.opened_url(), Some("https://zed.dev/channel/had-(oops)".into()) ); } #[gpui::test] async fn test_urls_at_beginning_of_buffer(cx: &mut gpui::TestAppContext) { init_test(cx, |_| {}); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { ..Default::default() }, cx, ) .await; cx.set_state(indoc! {"https://zed.dev/releases is a cool ˇwebpage."}); let screen_coord = cx.pixel_position(indoc! {"https://zed.dev/relˇeases is a cool webpage."}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); cx.assert_editor_text_highlights::( indoc! {"«https://zed.dev/releasesˇ» is a cool webpage."}, ); cx.simulate_click(screen_coord, Modifiers::secondary_key()); assert_eq!(cx.opened_url(), Some("https://zed.dev/releases".into())); } #[gpui::test] async fn test_urls_at_end_of_buffer(cx: &mut gpui::TestAppContext) { init_test(cx, |_| {}); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { ..Default::default() }, cx, ) .await; cx.set_state(indoc! {"A cool ˇwebpage is https://zed.dev/releases"}); let screen_coord = cx.pixel_position(indoc! {"A cool webpage is https://zed.dev/releˇases"}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); cx.assert_editor_text_highlights::( indoc! {"A cool webpage is «https://zed.dev/releasesˇ»"}, ); cx.simulate_click(screen_coord, Modifiers::secondary_key()); assert_eq!(cx.opened_url(), Some("https://zed.dev/releases".into())); } #[gpui::test] async fn test_surrounding_filename(cx: &mut gpui::TestAppContext) { init_test(cx, |_| {}); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { ..Default::default() }, cx, ) .await; let test_cases = [ ("file ˇ name", None), ("ˇfile name", Some("file")), ("file ˇname", Some("name")), ("fiˇle name", Some("file")), ("filenˇame", Some("filename")), // Absolute path ("foobar ˇ/home/user/f.txt", Some("/home/user/f.txt")), ("foobar /home/useˇr/f.txt", Some("/home/user/f.txt")), // Windows ("C:\\Useˇrs\\user\\f.txt", Some("C:\\Users\\user\\f.txt")), // Whitespace ("ˇfile\\ -\\ name.txt", Some("file - name.txt")), ("file\\ -\\ naˇme.txt", Some("file - name.txt")), // Tilde ("ˇ~/file.txt", Some("~/file.txt")), ("~/fiˇle.txt", Some("~/file.txt")), // Double quotes ("\"fˇile.txt\"", Some("file.txt")), ("ˇ\"file.txt\"", Some("file.txt")), ("ˇ\"fi\\ le.txt\"", Some("fi le.txt")), // Single quotes ("'fˇile.txt'", Some("file.txt")), ("ˇ'file.txt'", Some("file.txt")), ("ˇ'fi\\ le.txt'", Some("fi le.txt")), ]; for (input, expected) in test_cases { cx.set_state(input); let (position, snapshot) = cx.editor(|editor, _, cx| { let positions = editor.selections.newest_anchor().head().text_anchor; let snapshot = editor .buffer() .clone() .read(cx) .as_singleton() .unwrap() .read(cx) .snapshot(); (positions, snapshot) }); let result = surrounding_filename(snapshot, position); if let Some(expected) = expected { assert!(result.is_some(), "Failed to find file path: {}", input); let (_, path) = result.unwrap(); assert_eq!(&path, expected, "Incorrect file path for input: {}", input); } else { assert!( result.is_none(), "Expected no result, but got one: {:?}", result ); } } } #[gpui::test] async fn test_hover_filenames(cx: &mut gpui::TestAppContext) { init_test(cx, |_| {}); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { ..Default::default() }, cx, ) .await; // Insert a new file let fs = cx.update_workspace(|workspace, _, cx| workspace.project().read(cx).fs().clone()); fs.as_fake() .insert_file( path!("/root/dir/file2.rs"), "This is file2.rs".as_bytes().to_vec(), ) .await; #[cfg(not(target_os = "windows"))] cx.set_state(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to /root/dir/file2.rs if project is local. Or go to /root/dir/file2 if this is a Rust file.ˇ "}); #[cfg(target_os = "windows")] cx.set_state(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to C:/root/dir/file2.rs if project is local. Or go to C:/root/dir/file2 if this is a Rust file.ˇ "}); // File does not exist #[cfg(not(target_os = "windows"))] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that dˇoes_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to /root/dir/file2.rs if project is local. Or go to /root/dir/file2 if this is a Rust file. "}); #[cfg(target_os = "windows")] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that dˇoes_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to C:/root/dir/file2.rs if project is local. Or go to C:/root/dir/file2 if this is a Rust file. "}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); // No highlight cx.update_editor(|editor, window, cx| { assert!( editor .snapshot(window, cx) .text_highlight_ranges::() .unwrap_or_default() .1 .is_empty() ); }); // Moving the mouse over a file that does exist should highlight it. #[cfg(not(target_os = "windows"))] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that does_not_exist.txt. Go to fˇile2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to /root/dir/file2.rs if project is local. Or go to /root/dir/file2 if this is a Rust file. "}); #[cfg(target_os = "windows")] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that does_not_exist.txt. Go to fˇile2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to C:/root/dir/file2.rs if project is local. Or go to C:/root/dir/file2 if this is a Rust file. "}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); #[cfg(not(target_os = "windows"))] cx.assert_editor_text_highlights::(indoc! {" You can't go to a file that does_not_exist.txt. Go to «file2.rsˇ» if you want. Or go to ../dir/file2.rs if you want. Or go to /root/dir/file2.rs if project is local. Or go to /root/dir/file2 if this is a Rust file. "}); #[cfg(target_os = "windows")] cx.assert_editor_text_highlights::(indoc! {" You can't go to a file that does_not_exist.txt. Go to «file2.rsˇ» if you want. Or go to ../dir/file2.rs if you want. Or go to C:/root/dir/file2.rs if project is local. Or go to C:/root/dir/file2 if this is a Rust file. "}); // Moving the mouse over a relative path that does exist should highlight it #[cfg(not(target_os = "windows"))] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/fˇile2.rs if you want. Or go to /root/dir/file2.rs if project is local. Or go to /root/dir/file2 if this is a Rust file. "}); #[cfg(target_os = "windows")] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/fˇile2.rs if you want. Or go to C:/root/dir/file2.rs if project is local. Or go to C:/root/dir/file2 if this is a Rust file. "}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); #[cfg(not(target_os = "windows"))] cx.assert_editor_text_highlights::(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to «../dir/file2.rsˇ» if you want. Or go to /root/dir/file2.rs if project is local. Or go to /root/dir/file2 if this is a Rust file. "}); #[cfg(target_os = "windows")] cx.assert_editor_text_highlights::(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to «../dir/file2.rsˇ» if you want. Or go to C:/root/dir/file2.rs if project is local. Or go to C:/root/dir/file2 if this is a Rust file. "}); // Moving the mouse over an absolute path that does exist should highlight it #[cfg(not(target_os = "windows"))] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to /root/diˇr/file2.rs if project is local. Or go to /root/dir/file2 if this is a Rust file. "}); #[cfg(target_os = "windows")] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to C:/root/diˇr/file2.rs if project is local. Or go to C:/root/dir/file2 if this is a Rust file. "}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); #[cfg(not(target_os = "windows"))] cx.assert_editor_text_highlights::(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to «/root/dir/file2.rsˇ» if project is local. Or go to /root/dir/file2 if this is a Rust file. "}); #[cfg(target_os = "windows")] cx.assert_editor_text_highlights::(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to «C:/root/dir/file2.rsˇ» if project is local. Or go to C:/root/dir/file2 if this is a Rust file. "}); // Moving the mouse over a path that exists, if we add the language-specific suffix, it should highlight it #[cfg(not(target_os = "windows"))] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to /root/dir/file2.rs if project is local. Or go to /root/diˇr/file2 if this is a Rust file. "}); #[cfg(target_os = "windows")] let screen_coord = cx.pixel_position(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to C:/root/dir/file2.rs if project is local. Or go to C:/root/diˇr/file2 if this is a Rust file. "}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); #[cfg(not(target_os = "windows"))] cx.assert_editor_text_highlights::(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to /root/dir/file2.rs if project is local. Or go to «/root/dir/file2ˇ» if this is a Rust file. "}); #[cfg(target_os = "windows")] cx.assert_editor_text_highlights::(indoc! {" You can't go to a file that does_not_exist.txt. Go to file2.rs if you want. Or go to ../dir/file2.rs if you want. Or go to C:/root/dir/file2.rs if project is local. Or go to «C:/root/dir/file2ˇ» if this is a Rust file. "}); cx.simulate_click(screen_coord, Modifiers::secondary_key()); cx.update_workspace(|workspace, _, cx| assert_eq!(workspace.items(cx).count(), 2)); cx.update_workspace(|workspace, _, cx| { let active_editor = workspace.active_item_as::(cx).unwrap(); let buffer = active_editor .read(cx) .buffer() .read(cx) .as_singleton() .unwrap(); let file = buffer.read(cx).file().unwrap(); let file_path = file.as_local().unwrap().abs_path(cx); assert_eq!( file_path, std::path::PathBuf::from(path!("/root/dir/file2.rs")) ); }); } #[gpui::test] async fn test_hover_directories(cx: &mut gpui::TestAppContext) { init_test(cx, |_| {}); let mut cx = EditorLspTestContext::new_rust( lsp::ServerCapabilities { ..Default::default() }, cx, ) .await; // Insert a new file let fs = cx.update_workspace(|workspace, _, cx| workspace.project().read(cx).fs().clone()); fs.as_fake() .insert_file("/root/dir/file2.rs", "This is file2.rs".as_bytes().to_vec()) .await; cx.set_state(indoc! {" You can't open ../diˇr because it's a directory. "}); // File does not exist let screen_coord = cx.pixel_position(indoc! {" You can't open ../diˇr because it's a directory. "}); cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key()); // No highlight cx.update_editor(|editor, window, cx| { assert!( editor .snapshot(window, cx) .text_highlight_ranges::() .unwrap_or_default() .1 .is_empty() ); }); // Does not open the directory cx.simulate_click(screen_coord, Modifiers::secondary_key()); cx.update_workspace(|workspace, _, cx| assert_eq!(workspace.items(cx).count(), 1)); } }