Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

helix: Add Helix's "Amp Jump" Feature (#43733)

Mikhail Pertsevb359a42d56cd
diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index d5bc26b9417..d57794e61a9 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -507,6 +507,7 @@
"shift-l": "pane::ActivateNextItem", // not a helix default
"g p": "pane::ActivatePreviousItem",
"shift-h": "pane::ActivatePreviousItem", // not a helix default
+ "g w": "vim::HelixJumpToWord",
"g .": "vim::HelixGotoLastModification",
"g o": "editor::ToggleSelectedDiffHunks", // Zed specific
"g shift-o": "git::ToggleStaged", // Zed specific
@@ -545,7 +546,6 @@
"]": ["vim::PushHelixNext", { "around": true }],
"[": ["vim::PushHelixPrevious", { "around": true }],
"g q": "vim::PushRewrap",
- "g w": "vim::PushRewrap", // not a helix default & clashes with helix `goto_word`
},
},
{
diff --git a/crates/settings_content/src/theme.rs b/crates/settings_content/src/theme.rs
index 623e463cfb6..3197ae0602a 100644
--- a/crates/settings_content/src/theme.rs
+++ b/crates/settings_content/src/theme.rs
@@ -1036,6 +1036,9 @@ pub struct ThemeColorsContent {
/// Background color for Vim yank highlight.
#[serde(rename = "vim.yank.background")]
pub vim_yank_background: Option<String>,
+ /// Foreground color for Helix jump labels.
+ #[serde(rename = "vim.helix_jump_label.foreground")]
+ pub vim_helix_jump_label_foreground: Option<String>,
/// Background color for Vim Helix Normal mode indicator.
#[serde(rename = "vim.helix_normal.background")]
pub vim_helix_normal_background: Option<String>,
diff --git a/crates/theme/src/default_colors.rs b/crates/theme/src/default_colors.rs
index fce0e54c720..14e1df38841 100644
--- a/crates/theme/src/default_colors.rs
+++ b/crates/theme/src/default_colors.rs
@@ -176,6 +176,7 @@ impl ThemeColors {
vim_visual_line_background: system.transparent,
vim_visual_block_background: system.transparent,
vim_yank_background: neutral().light_alpha().step_3(),
+ vim_helix_jump_label_foreground: red().light().step_9(),
vim_helix_normal_background: system.transparent,
vim_helix_select_background: system.transparent,
vim_normal_foreground: system.transparent,
@@ -322,6 +323,7 @@ impl ThemeColors {
vim_visual_line_background: system.transparent,
vim_visual_block_background: system.transparent,
vim_yank_background: neutral().dark_alpha().step_4(),
+ vim_helix_jump_label_foreground: red().dark().step_9(),
vim_helix_normal_background: system.transparent,
vim_helix_select_background: system.transparent,
vim_normal_foreground: system.transparent,
diff --git a/crates/theme/src/fallback_themes.rs b/crates/theme/src/fallback_themes.rs
index a739df3213d..22a2c737048 100644
--- a/crates/theme/src/fallback_themes.rs
+++ b/crates/theme/src/fallback_themes.rs
@@ -260,6 +260,7 @@ pub(crate) fn zed_default_dark() -> Theme {
vim_visual_line_background: SystemColors::default().transparent,
vim_visual_block_background: SystemColors::default().transparent,
vim_yank_background: hsla(207.8 / 360., 81. / 100., 66. / 100., 0.2),
+ vim_helix_jump_label_foreground: red,
vim_helix_normal_background: SystemColors::default().transparent,
vim_helix_select_background: SystemColors::default().transparent,
vim_normal_foreground: SystemColors::default().transparent,
diff --git a/crates/theme/src/styles/colors.rs b/crates/theme/src/styles/colors.rs
index 75ba8ea3918..63ccdacca7a 100644
--- a/crates/theme/src/styles/colors.rs
+++ b/crates/theme/src/styles/colors.rs
@@ -177,6 +177,8 @@ pub struct ThemeColors {
pub vim_visual_block_background: Hsla,
/// Background color for Vim yank highlight.
pub vim_yank_background: Hsla,
+ /// Foreground color for Helix jump labels.
+ pub vim_helix_jump_label_foreground: Hsla,
/// Background color for Vim Helix Normal mode indicator.
pub vim_helix_normal_background: Hsla,
/// Background color for Vim Helix Select mode indicator.
diff --git a/crates/theme_settings/src/schema.rs b/crates/theme_settings/src/schema.rs
index 93eb4d30aa7..76c2e2a8b24 100644
--- a/crates/theme_settings/src/schema.rs
+++ b/crates/theme_settings/src/schema.rs
@@ -775,6 +775,11 @@ pub fn theme_colors_refinement(
.as_ref()
.and_then(|color| try_parse_color(color).ok())
.or(editor_document_highlight_read_background),
+ vim_helix_jump_label_foreground: this
+ .vim_helix_jump_label_foreground
+ .as_ref()
+ .and_then(|color| try_parse_color(color).ok())
+ .or(status_colors.error),
vim_helix_normal_background: this
.vim_helix_normal_background
.as_ref()
@@ -848,3 +853,39 @@ fn try_parse_color(color: &str) -> anyhow::Result<Hsla> {
Ok(hsla)
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn helix_jump_label_color_uses_theme_color_or_status_error() {
+ let status_error = try_parse_color("#e63333").expect("valid color");
+ let override_color = try_parse_color("#00ff00").expect("valid color");
+ let status_colors = StatusColorsRefinement {
+ error: Some(status_error),
+ ..Default::default()
+ };
+
+ let fallback_refinement =
+ theme_colors_refinement(&ThemeColorsContent::default(), &status_colors);
+
+ assert_eq!(
+ fallback_refinement.vim_helix_jump_label_foreground,
+ Some(status_error)
+ );
+
+ let override_refinement = theme_colors_refinement(
+ &ThemeColorsContent {
+ vim_helix_jump_label_foreground: Some("#00ff00".to_string()),
+ ..Default::default()
+ },
+ &status_colors,
+ );
+
+ assert_eq!(
+ override_refinement.vim_helix_jump_label_foreground,
+ Some(override_color)
+ );
+ }
+}
diff --git a/crates/vim/src/helix.rs b/crates/vim/src/helix.rs
index fe25852682c..eebad4d4382 100644
--- a/crates/vim/src/helix.rs
+++ b/crates/vim/src/helix.rs
@@ -5,27 +5,29 @@ mod paste;
mod select;
mod surround;
-use editor::display_map::DisplaySnapshot;
+use editor::display_map::{DisplayRow, DisplaySnapshot};
use editor::{
DisplayPoint, Editor, EditorSettings, HideMouseCursorOrigin, MultiBufferOffset,
- SelectionEffects, ToOffset, ToPoint, movement,
+ NavigationOverlayLabel, NavigationTargetOverlay, SelectionEffects, ToOffset, ToPoint, movement,
};
use gpui::actions;
-use gpui::{Context, Window};
-use language::{CharClassifier, CharKind, Point};
+use gpui::{App, Context, Font, Hsla, Pixels, Window, WindowTextSystem};
+use language::{CharClassifier, CharKind, Point, Selection};
+use multi_buffer::MultiBufferSnapshot;
use search::{BufferSearchBar, SearchOptions};
use settings::Settings;
use text::{Bias, SelectionGoal};
-use workspace::searchable::FilteredSearchRange;
-use workspace::searchable::{self, Direction};
+use theme::ActiveTheme as _;
+use ui::px;
+use workspace::searchable::{self, Direction, FilteredSearchRange};
use crate::motion::{self, MotionKind};
-use crate::state::{Operator, SearchState};
+use crate::state::{HelixJumpBehaviour, HelixJumpLabel, Mode, Operator, SearchState};
use crate::{
PushHelixSurroundAdd, PushHelixSurroundDelete, PushHelixSurroundReplace, Vim,
motion::{Motion, right},
- state::Mode,
};
+use std::ops::Range;
actions!(
vim,
@@ -55,6 +57,8 @@ actions!(
HelixSubstitute,
/// Delete the selection and enter edit mode, without yanking the selection.
HelixSubstituteNoYank,
+ /// Activate Helix-style word jump labels.
+ HelixJumpToWord,
/// Select the next match for the current search query.
HelixSelectNext,
/// Select the previous match for the current search query.
@@ -82,6 +86,7 @@ pub fn register(editor: &mut Editor, cx: &mut Context<Vim>) {
});
Vim::action(editor, cx, Vim::helix_substitute);
Vim::action(editor, cx, Vim::helix_substitute_no_yank);
+ Vim::action(editor, cx, Vim::helix_jump_to_word);
Vim::action(editor, cx, Vim::helix_select_next);
Vim::action(editor, cx, Vim::helix_select_previous);
Vim::action(editor, cx, |vim, _: &PushHelixSurroundAdd, window, cx| {
@@ -972,20 +977,876 @@ impl Vim {
});
}
}
+
+ pub fn helix_jump_to_word(
+ &mut self,
+ _: &HelixJumpToWord,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ let behaviour = if self.mode.is_visual() {
+ HelixJumpBehaviour::Extend
+ } else {
+ HelixJumpBehaviour::Move
+ };
+ self.start_helix_jump(behaviour, window, cx);
+ }
+
+ fn start_helix_jump(
+ &mut self,
+ behaviour: HelixJumpBehaviour,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ let is_visual = self.mode.is_visual();
+ let Some(data) = self.collect_helix_jump_data(is_visual, window, cx) else {
+ return;
+ };
+
+ if data.labels.is_empty() {
+ self.clear_helix_jump_ui(window, cx);
+ return;
+ }
+
+ if !self.apply_helix_jump_ui(data.overlays, window, cx) {
+ return;
+ }
+
+ self.push_operator(
+ Operator::HelixJump {
+ behaviour,
+ first_char: None,
+ labels: data.labels,
+ },
+ window,
+ cx,
+ );
+ }
+
+ fn collect_helix_jump_data(
+ &mut self,
+ is_visual: bool,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) -> Option<HelixJumpUiData> {
+ self.update_editor(cx, |_, editor, cx| {
+ let snapshot = editor.snapshot(window, cx);
+ let display_snapshot = &snapshot.display_snapshot;
+ let buffer_snapshot = display_snapshot.buffer_snapshot();
+ let visible_range = Self::visible_jump_range(editor, &snapshot, display_snapshot, cx);
+ let start_offset = buffer_snapshot.point_to_offset(visible_range.start);
+ let end_offset = buffer_snapshot.point_to_offset(visible_range.end);
+
+ let selections = editor.selections.all::<Point>(&display_snapshot);
+ let skip_data = Self::selection_skip_offsets(buffer_snapshot, &selections, is_visual);
+
+ // Get the primary cursor position for alternating forward/backward labeling
+ let cursor_offset = selections
+ .first()
+ .map(|s| buffer_snapshot.point_to_offset(s.head()))
+ .unwrap_or(start_offset);
+
+ let style = editor.style(cx);
+ let font = style.text.font();
+ let font_size = style.text.font_size.to_pixels(window.rem_size());
+ let label_color = cx.theme().colors().vim_helix_jump_label_foreground;
+
+ Self::build_helix_jump_ui_data(
+ buffer_snapshot,
+ start_offset,
+ end_offset,
+ cursor_offset,
+ label_color,
+ &skip_data,
+ window.text_system(),
+ font,
+ font_size,
+ )
+ })
+ }
+
+ fn visible_jump_range(
+ editor: &Editor,
+ snapshot: &editor::EditorSnapshot,
+ display_snapshot: &DisplaySnapshot,
+ cx: &App,
+ ) -> Range<Point> {
+ let visible_range = editor.multi_buffer_visible_range(display_snapshot, cx);
+ if editor.visible_line_count().is_some() || visible_range.start != visible_range.end {
+ return visible_range;
+ }
+
+ let scroll_position = snapshot.scroll_position();
+ let top_row = scroll_position.y.floor().max(0.0) as u32;
+ let visible_rows = display_snapshot
+ .max_point()
+ .row()
+ .0
+ .saturating_sub(top_row)
+ .saturating_add(1);
+ let start_display_point = DisplayPoint::new(DisplayRow(top_row), 0);
+ let end_display_point =
+ DisplayPoint::new(DisplayRow(top_row.saturating_add(visible_rows)), 0);
+
+ display_snapshot.display_point_to_point(start_display_point, Bias::Left)
+ ..display_snapshot.display_point_to_point(end_display_point, Bias::Right)
+ }
+
+ fn build_helix_jump_ui_data(
+ buffer: &MultiBufferSnapshot,
+ start_offset: MultiBufferOffset,
+ end_offset: MultiBufferOffset,
+ cursor_offset: MultiBufferOffset,
+ label_color: Hsla,
+ skip_data: &HelixJumpSkipData,
+ text_system: &WindowTextSystem,
+ font: Font,
+ font_size: Pixels,
+ ) -> HelixJumpUiData {
+ if start_offset >= end_offset {
+ return HelixJumpUiData::default();
+ }
+
+ // First pass: collect all word candidates without assigning labels
+ let candidates = Self::collect_jump_candidates(buffer, start_offset, end_offset, skip_data);
+
+ if candidates.is_empty() {
+ return HelixJumpUiData::default();
+ }
+
+ let ordered_candidates = Self::order_jump_candidates(candidates, cursor_offset);
+
+ // Now assign labels and build UI data
+ let mut labels = Vec::with_capacity(ordered_candidates.len());
+ let mut overlays = Vec::with_capacity(ordered_candidates.len());
+
+ let width_of = |text: &str| -> Pixels {
+ if text.is_empty() {
+ return px(0.0);
+ }
+
+ let run = gpui::TextRun {
+ len: text.len(),
+ font: font.clone(),
+ color: Hsla::default(),
+ background_color: None,
+ underline: None,
+ strikethrough: None,
+ };
+
+ text_system.layout_line(text, font_size, &[run], None).width
+ };
+
+ let is_monospace = Self::is_monospace_jump_font(text_system, &font, font_size);
+
+ for (label_index, candidate) in ordered_candidates.into_iter().enumerate() {
+ let start_anchor = buffer.anchor_after(candidate.word_start);
+ let end_anchor = buffer.anchor_after(candidate.word_end);
+ let label = Self::jump_label_for_index(label_index);
+ let label_text = label.iter().collect::<String>();
+ // Monospace fonts: the label always matches the width of the first two characters,
+ // so no per-word measurement is needed.
+ // Proportional fonts: a label like "mw" can be wider than a short word like "if",
+ // so we hide enough of the word (and possibly trailing whitespace) to make room,
+ // or shift the label left into preceding whitespace.
+ let fit = if is_monospace {
+ JumpLabelFit::monospace(candidate.first_two_end)
+ } else {
+ let label_width = width_of(&label_text);
+ Self::fit_proportional_jump_label(
+ buffer,
+ &candidate,
+ end_offset,
+ label_width,
+ &width_of,
+ )
+ };
+
+ let hide_end_anchor = buffer.anchor_after(fit.hide_end_offset);
+
+ labels.push(HelixJumpLabel {
+ label,
+ range: start_anchor..end_anchor,
+ });
+
+ overlays.push(NavigationTargetOverlay {
+ target_range: start_anchor..end_anchor,
+ label: NavigationOverlayLabel {
+ text: label_text.into(),
+ text_color: label_color,
+ x_offset: -fit.left_shift,
+ scale_factor: fit.scale_factor,
+ },
+ covered_text_range: Some(start_anchor..hide_end_anchor),
+ });
+ }
+
+ HelixJumpUiData { labels, overlays }
+ }
+
+ fn collect_jump_candidates(
+ buffer: &MultiBufferSnapshot,
+ start_offset: MultiBufferOffset,
+ end_offset: MultiBufferOffset,
+ skip_data: &HelixJumpSkipData,
+ ) -> Vec<JumpCandidate> {
+ let mut candidates = Vec::new();
+
+ let mut offset = start_offset;
+ let mut in_word = false;
+ let mut word_start = start_offset;
+ let mut first_two_end = start_offset;
+ let mut char_count = 0;
+
+ for chunk in buffer.text_for_range(start_offset..end_offset) {
+ for (idx, ch) in chunk.char_indices() {
+ let absolute = offset + idx;
+ let is_word = is_jump_word_char(ch);
+ if is_word {
+ if !in_word {
+ in_word = true;
+ word_start = absolute;
+ char_count = 0;
+ }
+ if char_count == 1 {
+ first_two_end = absolute + ch.len_utf8();
+ }
+ char_count += 1;
+ }
+
+ if !is_word && in_word {
+ if char_count >= 2
+ && !Self::should_skip_jump_candidate(word_start, absolute, skip_data)
+ {
+ candidates.push(JumpCandidate {
+ word_start,
+ word_end: absolute,
+ first_two_end,
+ });
+ }
+ in_word = false;
+ }
+ }
+ offset += chunk.len();
+ }
+
+ // Handle word at end of buffer
+ if in_word
+ && char_count >= 2
+ && !Self::should_skip_jump_candidate(word_start, end_offset, skip_data)
+ {
+ candidates.push(JumpCandidate {
+ word_start,
+ word_end: end_offset,
+ first_two_end,
+ });
+ }
+
+ candidates
+ }
+
+ fn selection_skip_offsets(
+ buffer: &MultiBufferSnapshot,
+ selections: &[Selection<Point>],
+ is_visual: bool,
+ ) -> HelixJumpSkipData {
+ let mut skip_points = Vec::with_capacity(selections.len());
+ let mut skip_ranges = Vec::new();
+
+ for selection in selections {
+ let head_offset = buffer.point_to_offset(selection.head());
+ skip_points.push(head_offset);
+
+ // In visual mode, don't skip ranges so we can shrink the selection
+ if !is_visual && selection.start != selection.end {
+ let mut start = buffer.point_to_offset(selection.start);
+ let mut end = buffer.point_to_offset(selection.end);
+ if start > end {
+ std::mem::swap(&mut start, &mut end);
+ }
+ skip_ranges.push(start..end);
+ }
+ }
+
+ skip_points.sort_unstable();
+
+ skip_ranges.sort_unstable_by_key(|range| range.start);
+ let mut merged_ranges: Vec<Range<MultiBufferOffset>> =
+ Vec::with_capacity(skip_ranges.len());
+ for range in skip_ranges {
+ if let Some(previous_range) = merged_ranges.last_mut()
+ && range.start <= previous_range.end
+ {
+ previous_range.end = previous_range.end.max(range.end);
+ } else {
+ merged_ranges.push(range);
+ }
+ }
+
+ HelixJumpSkipData {
+ points: skip_points,
+ ranges: merged_ranges,
+ }
+ }
+
+ fn should_skip_jump_candidate(
+ word_start: MultiBufferOffset,
+ word_end: MultiBufferOffset,
+ skip_data: &HelixJumpSkipData,
+ ) -> bool {
+ // word_end is exclusive, so points at the following delimiter should not skip the word.
+ let point_index = skip_data
+ .points
+ .partition_point(|offset| *offset < word_start);
+ if skip_data
+ .points
+ .get(point_index)
+ .is_some_and(|offset| *offset < word_end)
+ {
+ return true;
+ }
+
+ let range_index = skip_data
+ .ranges
+ .partition_point(|range| range.end <= word_start);
+ skip_data
+ .ranges
+ .get(range_index)
+ .is_some_and(|range| range.start < word_end)
+ }
+
+ /// Interleave candidates so forward targets get even label indices (aa, ac, ae...)
+ /// and backward targets get odd indices (ab, ad, af...), matching Helix's algorithm.
+ /// This keeps the earliest label assignments close to the cursor in both directions.
+ fn order_jump_candidates(
+ candidates: Vec<JumpCandidate>,
+ cursor_offset: MultiBufferOffset,
+ ) -> Vec<JumpCandidate> {
+ let mut forward = Vec::with_capacity(candidates.len());
+ let mut backward = Vec::new();
+
+ for candidate in candidates {
+ if candidate.word_start < cursor_offset {
+ backward.push(candidate);
+ } else {
+ forward.push(candidate);
+ }
+ }
+
+ backward.reverse();
+
+ let mut ordered_candidates =
+ Vec::with_capacity((forward.len() + backward.len()).min(HELIX_JUMP_LABEL_LIMIT));
+ let mut forward_candidates = forward.into_iter();
+ let mut backward_candidates = backward.into_iter();
+
+ loop {
+ let mut pushed_candidate = false;
+
+ if ordered_candidates.len() < HELIX_JUMP_LABEL_LIMIT
+ && let Some(candidate) = forward_candidates.next()
+ {
+ ordered_candidates.push(candidate);
+ pushed_candidate = true;
+ }
+
+ if ordered_candidates.len() < HELIX_JUMP_LABEL_LIMIT
+ && let Some(candidate) = backward_candidates.next()
+ {
+ ordered_candidates.push(candidate);
+ pushed_candidate = true;
+ }
+
+ if !pushed_candidate {
+ break;
+ }
+ }
+
+ ordered_candidates
+ }
+
+ fn jump_label_for_index(index: usize) -> [char; 2] {
+ [
+ HELIX_JUMP_ALPHABET[index / HELIX_JUMP_ALPHABET.len()],
+ HELIX_JUMP_ALPHABET[index % HELIX_JUMP_ALPHABET.len()],
+ ]
+ }
+
+ fn is_monospace_jump_font(
+ text_system: &WindowTextSystem,
+ font: &Font,
+ font_size: Pixels,
+ ) -> bool {
+ let font_id = text_system.resolve_font(font);
+ let width_of_char = |ch| {
+ text_system
+ .advance(font_id, font_size, ch)
+ .map(|size| size.width)
+ .unwrap_or_else(|_| text_system.layout_width(font_id, font_size, ch))
+ };
+
+ let a = width_of_char('i');
+ let b = width_of_char('w');
+ let c = width_of_char('0');
+ let d = width_of_char('1');
+ let diff_1 = if a > b { a - b } else { b - a };
+ let diff_2 = if c > d { c - d } else { d - c };
+ diff_1 <= HELIX_JUMP_MONOSPACE_TOLERANCE && diff_2 <= HELIX_JUMP_MONOSPACE_TOLERANCE
+ }
+
+ /// Fit a jump label over a word in a proportional font.
+ ///
+ /// Prefer fitting within the word itself, using available whitespace to the left
+ /// before consuming trailing whitespace after the word. If the label still cannot
+ /// fit cleanly, allow a small amount of scaling.
+ fn fit_proportional_jump_label<F: Fn(&str) -> Pixels>(
+ buffer: &MultiBufferSnapshot,
+ candidate: &JumpCandidate,
+ end_offset: MultiBufferOffset,
+ label_width: Pixels,
+ width_of: &F,
+ ) -> JumpLabelFit {
+ let fit_budget = Self::jump_label_fit_budget(buffer, candidate, end_offset, width_of);
+
+ let mut hidden_prefix = HiddenPrefixFitState::new(candidate.first_two_end);
+ let min_label_scale = if fit_budget.preserve_full_scale {
+ 1.0
+ } else {
+ HELIX_JUMP_MIN_LABEL_SCALE
+ };
+
+ hidden_prefix.extend_to_fit(
+ buffer,
+ candidate.word_start,
+ candidate.word_end,
+ candidate.word_end,
+ label_width,
+ fit_budget.max_left_shift,
+ min_label_scale,
+ width_of,
+ );
+
+ if label_width > px(0.0)
+ && hidden_prefix.needs_more_width(label_width, fit_budget.max_left_shift)
+ && fit_budget.allowed_trailing_hide_end > candidate.word_end
+ {
+ hidden_prefix.extend_to_fit(
+ buffer,
+ candidate.word_end,
+ fit_budget.allowed_trailing_hide_end,
+ candidate.word_end,
+ label_width,
+ fit_budget.max_left_shift,
+ min_label_scale,
+ width_of,
+ );
+ }
+
+ // Jump candidates always contain at least two word characters, and the initial
+ // scan above always measures through that second character before we read the width.
+ let hidden_width = hidden_prefix.hidden_width;
+
+ let left_shift = if label_width > hidden_width {
+ (label_width - hidden_width).min(fit_budget.max_left_shift)
+ } else {
+ px(0.0)
+ };
+
+ let scale_factor = if label_width > px(0.0) {
+ let scale = ((hidden_width + left_shift) / label_width).min(1.0);
+ if scale < 1.0 { scale * 0.99 } else { 1.0 }
+ } else {
+ 1.0
+ };
+
+ JumpLabelFit {
+ hide_end_offset: hidden_prefix.hide_end_offset,
+ left_shift,
+ scale_factor: if fit_budget.preserve_full_scale {
+ 1.0
+ } else {
+ scale_factor
+ },
+ }
+ }
+
+ fn jump_label_fit_budget<F: Fn(&str) -> Pixels>(
+ buffer: &MultiBufferSnapshot,
+ candidate: &JumpCandidate,
+ end_offset: MultiBufferOffset,
+ width_of: &F,
+ ) -> JumpLabelFitBudget {
+ let mut left_ws_rev = String::new();
+ let mut left_ws_count = 0usize;
+ let mut left_stopped_at_line_break = false;
+ let mut left_stopped_at_non_ws = false;
+ let mut left_hit_limit = false;
+
+ for ch in buffer.reversed_chars_at(candidate.word_start) {
+ if ch == '\n' || ch == '\r' {
+ left_stopped_at_line_break = true;
+ break;
+ }
+
+ if !ch.is_whitespace() {
+ left_stopped_at_non_ws = true;
+ break;
+ }
+
+ left_ws_count += 1;
+ if left_ws_count > HELIX_JUMP_MAX_LEFT_WS_CHARS {
+ left_hit_limit = true;
+ break;
+ }
+
+ left_ws_rev.push(ch);
+ }
+
+ let left_ws: String = left_ws_rev.chars().rev().collect();
+ let left_ws_width = width_of(&left_ws);
+ let left_is_indentation =
+ left_stopped_at_line_break || (!left_stopped_at_non_ws && !left_hit_limit);
+ // Between tokens leave a small gap so the label doesn't touch the previous word;
+ // for line-leading indentation the full width is safe.
+ let min_left_gap = if left_is_indentation {
+ px(0.0)
+ } else {
+ px(2.0)
+ };
+ let max_left_shift = (left_ws_width - min_left_gap).max(px(0.0));
+
+ let mut allowed_trailing_hide_end = candidate.word_end;
+ let mut ws_count = 0usize;
+ let mut last_ws_start = candidate.word_end;
+ let mut ws_end_offset = candidate.word_end;
+ let mut next_non_ws = None;
+ let mut hit_line_break_after_word = false;
+
+ let mut ws_scan_offset = candidate.word_end;
+ 'scan: for chunk in buffer.text_for_range(candidate.word_end..end_offset) {
+ for (idx, ch) in chunk.char_indices() {
+ let absolute = ws_scan_offset + idx;
+ if ch == '\n' || ch == '\r' {
+ hit_line_break_after_word = true;
+ break 'scan;
+ }
+ if !ch.is_whitespace() {
+ next_non_ws = Some(ch);
+ break 'scan;
+ }
+
+ ws_count += 1;
+ last_ws_start = absolute;
+ ws_end_offset = absolute + ch.len_utf8();
+ }
+ ws_scan_offset += chunk.len();
+ }
+
+ let preserve_full_scale = hit_line_break_after_word && next_non_ws.is_none()
+ || matches!(
+ buffer.chars_at(candidate.word_end).next(),
+ None | Some('\n') | Some('\r')
+ );
+
+ if ws_count > 0 {
+ let next_is_word = match next_non_ws {
+ Some(ch) => is_jump_word_char(ch),
+ None => false,
+ };
+
+ if next_is_word {
+ // Keep at least one whitespace character visible so adjacent labels
+ // remain visually separated.
+ if ws_count > 1 {
+ allowed_trailing_hide_end = last_ws_start;
+ }
+ } else {
+ // Next token is punctuation or end-of-range — safe to hide all whitespace.
+ allowed_trailing_hide_end = ws_end_offset;
+ }
+ }
+
+ JumpLabelFitBudget {
+ max_left_shift,
+ allowed_trailing_hide_end,
+ preserve_full_scale,
+ }
+ }
+}
+
+const HELIX_JUMP_ALPHABET: &[char; 26] = &[
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+ 't', 'u', 'v', 'w', 'x', 'y', 'z',
+];
+const HELIX_JUMP_LABEL_LIMIT: usize = HELIX_JUMP_ALPHABET.len() * HELIX_JUMP_ALPHABET.len();
+const HELIX_JUMP_MONOSPACE_TOLERANCE: Pixels = px(0.5);
+const HELIX_JUMP_MIN_LABEL_SCALE: f32 = 1.0;
+const HELIX_JUMP_MAX_HIDDEN_CHARS: usize = 16;
+const HELIX_JUMP_MAX_LEFT_WS_CHARS: usize = 32;
+
+fn is_jump_word_char(ch: char) -> bool {
+ ch == '_' || ch.is_alphanumeric()
+}
+
+/// A word candidate for jump labels, before label assignment.
+#[derive(Clone)]
+struct JumpCandidate {
+ word_start: MultiBufferOffset,
+ word_end: MultiBufferOffset,
+ first_two_end: MultiBufferOffset,
+}
+
+struct HelixJumpSkipData {
+ points: Vec<MultiBufferOffset>,
+ ranges: Vec<Range<MultiBufferOffset>>,
+}
+
+struct JumpLabelFit {
+ hide_end_offset: MultiBufferOffset,
+ left_shift: Pixels,
+ scale_factor: f32,
+}
+
+struct JumpLabelFitBudget {
+ max_left_shift: Pixels,
+ allowed_trailing_hide_end: MultiBufferOffset,
+ preserve_full_scale: bool,
+}
+
+struct HiddenPrefixFitState {
+ text: String,
+ hide_end_offset: MultiBufferOffset,
+ hidden_width: Pixels,
+ total_char_count: usize,
+ word_char_count: usize,
+}
+
+impl JumpLabelFit {
+ fn monospace(hide_end_offset: MultiBufferOffset) -> Self {
+ Self {
+ hide_end_offset,
+ left_shift: px(0.0),
+ scale_factor: 1.0,
+ }
+ }
+}
+
+impl HiddenPrefixFitState {
+ fn new(hide_end_offset: MultiBufferOffset) -> Self {
+ Self {
+ text: String::new(),
+ hide_end_offset,
+ hidden_width: px(0.0),
+ total_char_count: 0,
+ word_char_count: 0,
+ }
+ }
+
+ fn needs_more_width(&self, label_width: Pixels, max_left_shift: Pixels) -> bool {
+ (self.hidden_width + max_left_shift) / label_width < HELIX_JUMP_MIN_LABEL_SCALE
+ }
+
+ fn extend_to_fit<F: Fn(&str) -> Pixels>(
+ &mut self,
+ buffer: &MultiBufferSnapshot,
+ range_start: MultiBufferOffset,
+ range_end: MultiBufferOffset,
+ word_end: MultiBufferOffset,
+ label_width: Pixels,
+ max_left_shift: Pixels,
+ min_label_scale: f32,
+ width_of: &F,
+ ) {
+ let mut offset = range_start;
+ for chunk in buffer.text_for_range(range_start..range_end) {
+ for (idx, ch) in chunk.char_indices() {
+ let absolute = offset + idx;
+
+ self.total_char_count += 1;
+ if self.total_char_count > HELIX_JUMP_MAX_HIDDEN_CHARS {
+ return;
+ }
+
+ self.text.push(ch);
+ let end_offset = absolute + ch.len_utf8();
+
+ if absolute < word_end && is_jump_word_char(ch) {
+ self.word_char_count += 1;
+ }
+
+ if self.word_char_count < 2 {
+ continue;
+ }
+
+ self.hide_end_offset = end_offset;
+ self.hidden_width = width_of(self.text.as_str());
+
+ let effective_width = self.hidden_width + max_left_shift;
+ let scale_needed = if label_width > px(0.0) {
+ (effective_width / label_width).min(1.0)
+ } else {
+ 1.0
+ };
+
+ if scale_needed >= min_label_scale {
+ return;
+ }
+ }
+ offset += chunk.len();
+ }
+ }
+}
+
+#[derive(Default)]
+struct HelixJumpUiData {
+ labels: Vec<HelixJumpLabel>,
+ overlays: Vec<NavigationTargetOverlay>,
}
#[cfg(test)]
mod test {
+ use std::{fmt::Write, time::Duration};
+
+ use editor::{HighlightKey, MultiBufferOffset};
use gpui::{KeyBinding, UpdateGlobal, VisualTestContext};
use indoc::indoc;
+ use language::Point;
use project::FakeFs;
use search::{ProjectSearchView, project_search};
use serde_json::json;
- use settings::SettingsStore;
+ use settings::{SettingsStore, ThemeColorsContent, ThemeStyleContent};
+ use theme::ActiveTheme as _;
use util::path;
use workspace::{DeploySearch, MultiWorkspace};
- use crate::{VimAddon, state::Mode, test::VimTestContext};
+ use super::HELIX_JUMP_LABEL_LIMIT;
+ use crate::{
+ HELIX_JUMP_OVERLAY_KEY, Vim, VimAddon,
+ state::{Mode, Operator},
+ test::VimTestContext,
+ };
+
+ fn active_helix_jump_labels(cx: &mut VimTestContext) -> Vec<(String, String)> {
+ cx.update_editor(|editor, window, cx| {
+ let labels = match editor
+ .addon::<VimAddon>()
+ .unwrap()
+ .entity
+ .read(cx)
+ .operator_stack
+ .last()
+ .cloned()
+ {
+ Some(Operator::HelixJump { labels, .. }) => labels,
+ other => panic!("expected active HelixJump operator, got {other:?}"),
+ };
+
+ let snapshot = editor.snapshot(window, cx);
+ let buffer_snapshot = snapshot.display_snapshot.buffer_snapshot();
+
+ labels
+ .into_iter()
+ .map(|label| {
+ let jump_label = label.label.iter().collect::<String>();
+ let word = buffer_snapshot
+ .text_for_range(label.range)
+ .collect::<String>();
+ (jump_label, word)
+ })
+ .collect()
+ })
+ }
+
+ fn helix_jump_label_for_word(cx: &mut VimTestContext, target_word: &str) -> String {
+ active_helix_jump_labels(cx)
+ .into_iter()
+ .find_map(|(label, word)| (word == target_word).then_some(label))
+ .unwrap_or_else(|| {
+ let mut message = String::new();
+ let labels = active_helix_jump_labels(cx);
+ let _ = write!(
+ &mut message,
+ "expected jump label for word {target_word:?}, available labels: {labels:?}"
+ );
+ panic!("{message}");
+ })
+ }
+
+ fn jump_to_word(cx: &mut VimTestContext, target_word: &str) {
+ cx.simulate_keystrokes("g w");
+
+ let label = helix_jump_label_for_word(cx, target_word);
+
+ let mut chars = label.chars();
+ let first = chars.next().expect("jump labels are two characters long");
+ let second = chars.next().expect("jump labels are two characters long");
+ cx.simulate_keystrokes(&format!("{first} {second}"));
+ }
+
+ fn active_helix_jump_overlay_counts(cx: &mut VimTestContext) -> (usize, usize) {
+ let covered_text_range_count = cx.update_editor(|editor, window, cx| {
+ let snapshot = editor.snapshot(window, cx);
+ snapshot
+ .text_highlight_ranges(HighlightKey::NavigationOverlay(HELIX_JUMP_OVERLAY_KEY))
+ .map(|ranges| ranges.as_ref().clone().1.len())
+ .unwrap_or_default()
+ });
+ let label_count = match cx.active_operator() {
+ Some(Operator::HelixJump { labels, .. }) => labels.len(),
+ _ => 0,
+ };
+
+ (covered_text_range_count, label_count)
+ }
+
+ fn assert_helix_jump_cleared(cx: &mut VimTestContext, expected_overlay_counts: (usize, usize)) {
+ assert_eq!(cx.active_operator(), None);
+ assert_eq!(
+ active_helix_jump_overlay_counts(cx),
+ expected_overlay_counts,
+ "expected Helix jump UI to be fully cleared"
+ );
+ }
+
+ fn helix_jump_labels_for_full_buffer(cx: &mut VimTestContext) -> Vec<(String, String)> {
+ cx.update_editor(|editor, window, cx| {
+ let snapshot = editor.snapshot(window, cx);
+ let display_snapshot = &snapshot.display_snapshot;
+ let buffer_snapshot = display_snapshot.buffer_snapshot();
+ let selections = editor.selections.all::<Point>(display_snapshot);
+ let skip_data = Vim::selection_skip_offsets(buffer_snapshot, &selections, false);
+ let cursor_offset = selections
+ .first()
+ .map(|selection| buffer_snapshot.point_to_offset(selection.head()))
+ .unwrap_or(MultiBufferOffset(0));
+ let style = editor.style(cx);
+ let font = style.text.font();
+ let font_size = style.text.font_size.to_pixels(window.rem_size());
+ let label_color = cx.theme().colors().vim_helix_jump_label_foreground;
+ let data = Vim::build_helix_jump_ui_data(
+ buffer_snapshot,
+ MultiBufferOffset(0),
+ buffer_snapshot.len(),
+ cursor_offset,
+ label_color,
+ &skip_data,
+ window.text_system(),
+ font,
+ font_size,
+ );
+
+ data.labels
+ .into_iter()
+ .map(|label| {
+ let jump_label = label.label.iter().collect::<String>();
+ let word = buffer_snapshot
+ .text_for_range(label.range)
+ .collect::<String>();
+ (jump_label, word)
+ })
+ .collect()
+ })
+ }
#[gpui::test]
async fn test_word_motions(cx: &mut gpui::TestAppContext) {
@@ -2386,6 +3247,374 @@ mod test {
);
}
+ #[gpui::test]
+ async fn test_helix_jump_starts_operator(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("ˇhello world\njump labels", Mode::HelixNormal);
+
+ cx.simulate_keystrokes("g w");
+
+ assert!(
+ matches!(cx.active_operator(), Some(Operator::HelixJump { .. })),
+ "expected HelixJump operator to be active"
+ )
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_cancels_on_escape(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("ˇhello world\njump labels", Mode::HelixNormal);
+ let overlay_counts = active_helix_jump_overlay_counts(&mut cx);
+
+ cx.simulate_keystrokes("g w");
+ cx.simulate_keystrokes("escape");
+
+ cx.assert_state("ˇhello world\njump labels", Mode::HelixNormal);
+ assert_helix_jump_cleared(&mut cx, overlay_counts);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_cancels_on_invalid_first_char(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("ˇalpha beta gamma", Mode::HelixNormal);
+ let overlay_counts = active_helix_jump_overlay_counts(&mut cx);
+
+ cx.simulate_keystrokes("g w");
+ cx.simulate_keystrokes("z");
+
+ cx.assert_state("ˇalpha beta gamma", Mode::HelixNormal);
+ assert_helix_jump_cleared(&mut cx, overlay_counts);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_cancels_on_invalid_second_char(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("ˇalpha beta gamma", Mode::HelixNormal);
+ let overlay_counts = active_helix_jump_overlay_counts(&mut cx);
+
+ cx.simulate_keystrokes("g w");
+ cx.simulate_keystrokes("a z");
+
+ cx.assert_state("ˇalpha beta gamma", Mode::HelixNormal);
+ assert_helix_jump_cleared(&mut cx, overlay_counts);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_keeps_full_overlay_after_first_key(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ let text = format!(
+ "ˇ{}",
+ (0..28)
+ .map(|index| format!("w{index:02}"))
+ .collect::<Vec<_>>()
+ .join(" ")
+ );
+ cx.set_state(&text, Mode::HelixNormal);
+
+ cx.simulate_keystrokes("g w");
+ let labels = active_helix_jump_labels(&mut cx);
+ let initial_overlay_counts = active_helix_jump_overlay_counts(&mut cx);
+ let first_group = labels
+ .first()
+ .and_then(|(label, _)| label.chars().next())
+ .expect("expected at least one helix jump label");
+ let next_group = labels
+ .iter()
+ .filter_map(|(label, _)| label.chars().next())
+ .find(|ch| *ch != first_group)
+ .expect("expected labels spanning more than one first-character group");
+
+ cx.simulate_keystrokes(&next_group.to_string());
+
+ assert_eq!(
+ active_helix_jump_overlay_counts(&mut cx),
+ initial_overlay_counts
+ );
+ assert!(
+ matches!(
+ cx.active_operator(),
+ Some(Operator::HelixJump {
+ first_char: Some(ch),
+ ..
+ }) if ch == next_group
+ ),
+ "expected HelixJump operator to keep the first typed label character"
+ );
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_includes_word_before_cursor_boundary(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("oneˇ two three", Mode::HelixNormal);
+
+ jump_to_word(&mut cx, "one");
+
+ cx.assert_state("«oneˇ» two three", Mode::HelixNormal);
+ assert_eq!(cx.active_operator(), None);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_skips_single_char_words(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("ˇa bb c dd e", Mode::HelixNormal);
+
+ let words = helix_jump_labels_for_full_buffer(&mut cx)
+ .into_iter()
+ .map(|(_, word)| word)
+ .collect::<Vec<_>>();
+
+ assert_eq!(words, vec!["bb".to_string(), "dd".to_string()]);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_handles_underscored_words(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("baz quxˇ foo_bar _private", Mode::HelixNormal);
+
+ let words = helix_jump_labels_for_full_buffer(&mut cx)
+ .into_iter()
+ .map(|(_, word)| word)
+ .collect::<Vec<_>>();
+
+ assert!(words.iter().any(|word| word == "foo_bar"));
+ assert!(words.iter().any(|word| word == "_private"));
+ assert!(!words.iter().any(|word| word == "foo"));
+ assert!(!words.iter().any(|word| word == "bar"));
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_at_end_of_buffer(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("alpha beta gammaˇ", Mode::HelixNormal);
+
+ jump_to_word(&mut cx, "gamma");
+
+ cx.assert_state("alpha beta «gammaˇ»", Mode::HelixNormal);
+ assert_eq!(cx.active_operator(), None);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_moves_to_target_word(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("ˇone two three", Mode::HelixNormal);
+
+ jump_to_word(&mut cx, "three");
+
+ cx.assert_state("one two «threeˇ»", Mode::HelixNormal);
+ assert_eq!(cx.active_operator(), None);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_extends_selection_forward(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("one «twoˇ» three four", Mode::HelixSelect);
+
+ jump_to_word(&mut cx, "four");
+
+ cx.assert_state("one «two three fourˇ»", Mode::HelixSelect);
+ assert_eq!(cx.active_operator(), None);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_extends_selection_backward_from_forward_selection(
+ cx: &mut gpui::TestAppContext,
+ ) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("one «twoˇ» three four", Mode::HelixSelect);
+
+ jump_to_word(&mut cx, "one");
+
+ cx.assert_state("«ˇone two» three four", Mode::HelixSelect);
+ assert_eq!(cx.active_operator(), None);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_extends_reversed_selection_backward(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("one two «ˇthree» four", Mode::HelixSelect);
+
+ jump_to_word(&mut cx, "one");
+
+ cx.assert_state("«ˇone two three» four", Mode::HelixSelect);
+ assert_eq!(cx.active_operator(), None);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_prioritizes_nearby_targets_before_truncating(
+ cx: &mut gpui::TestAppContext,
+ ) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+
+ let cursor_index = 850usize;
+ let target_word = format!("w{:03}", cursor_index + 1);
+ let early_word = "w010".to_string();
+ let text = (0..900usize)
+ .map(|index| {
+ let word = format!("w{index:03}");
+ if index == cursor_index {
+ format!("ˇ{word}")
+ } else {
+ word
+ }
+ })
+ .collect::<Vec<_>>()
+ .join(" ");
+ cx.set_state(&text, Mode::HelixNormal);
+
+ let labels = helix_jump_labels_for_full_buffer(&mut cx);
+
+ assert_eq!(labels.len(), HELIX_JUMP_LABEL_LIMIT);
+ assert!(
+ labels.iter().any(|(_, word)| word == &target_word),
+ "expected nearby target {target_word:?} to survive truncation"
+ );
+ assert!(
+ !labels.iter().any(|(_, word)| word == &early_word),
+ "expected distant early target {early_word:?} to be truncated first"
+ );
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_label_ordering_alternates_directions(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("aaa bbb ccc ˇddd eee fff ggg", Mode::HelixNormal);
+
+ let first_labels = helix_jump_labels_for_full_buffer(&mut cx)
+ .into_iter()
+ .take(6)
+ .collect::<Vec<_>>();
+
+ assert_eq!(
+ first_labels,
+ vec![
+ ("aa".to_string(), "eee".to_string()),
+ ("ab".to_string(), "ccc".to_string()),
+ ("ac".to_string(), "fff".to_string()),
+ ("ad".to_string(), "bbb".to_string()),
+ ("ae".to_string(), "ggg".to_string()),
+ ("af".to_string(), "aaa".to_string()),
+ ]
+ );
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_uses_theme_label_color(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.update(|_, cx| {
+ SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings.theme.experimental_theme_overrides = Some(ThemeStyleContent {
+ colors: ThemeColorsContent {
+ vim_helix_jump_label_foreground: Some("#00ff00".to_string()),
+ ..Default::default()
+ },
+ ..Default::default()
+ });
+ });
+ });
+ });
+ cx.executor().advance_clock(Duration::from_millis(200));
+ cx.run_until_parked();
+
+ let configured_label_color =
+ cx.update(|_, cx| cx.theme().colors().vim_helix_jump_label_foreground);
+ assert_ne!(
+ configured_label_color,
+ cx.update(|_, cx| cx.theme().status().error)
+ );
+ cx.set_state("ˇalpha beta gamma", Mode::HelixNormal);
+
+ let label_colors = cx.update_editor(|editor, window, cx| {
+ let snapshot = editor.snapshot(window, cx);
+ let display_snapshot = &snapshot.display_snapshot;
+ let buffer_snapshot = display_snapshot.buffer_snapshot();
+ let selections = editor.selections.all::<Point>(display_snapshot);
+ let skip_data = Vim::selection_skip_offsets(buffer_snapshot, &selections, false);
+ let cursor_offset = selections
+ .first()
+ .map(|selection| buffer_snapshot.point_to_offset(selection.head()))
+ .unwrap_or(MultiBufferOffset(0));
+ let style = editor.style(cx);
+ let font = style.text.font();
+ let font_size = style.text.font_size.to_pixels(window.rem_size());
+ let data = Vim::build_helix_jump_ui_data(
+ buffer_snapshot,
+ MultiBufferOffset(0),
+ buffer_snapshot.len(),
+ cursor_offset,
+ configured_label_color,
+ &skip_data,
+ window.text_system(),
+ font,
+ font_size,
+ );
+
+ data.overlays
+ .into_iter()
+ .map(|overlay| overlay.label.text_color)
+ .collect::<Vec<_>>()
+ });
+
+ assert!(!label_colors.is_empty());
+ assert!(
+ label_colors
+ .into_iter()
+ .all(|color| color == configured_label_color)
+ );
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_input_is_case_insensitive(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("ˇone two three", Mode::HelixNormal);
+
+ cx.simulate_keystrokes("g w");
+ let label = helix_jump_label_for_word(&mut cx, "three");
+ let mut chars = label.chars();
+ let first = chars
+ .next()
+ .expect("jump labels are two characters long")
+ .to_ascii_uppercase();
+ let second = chars
+ .next()
+ .expect("jump labels are two characters long")
+ .to_ascii_uppercase();
+
+ cx.simulate_keystrokes(&format!("{first} {second}"));
+
+ cx.assert_state("one two «threeˇ»", Mode::HelixNormal);
+ assert_eq!(cx.active_operator(), None);
+ }
+
+ #[gpui::test]
+ async fn test_helix_jump_with_unicode_words(cx: &mut gpui::TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ cx.enable_helix();
+ cx.set_state("ˇcafé résumé naïve", Mode::HelixNormal);
+
+ jump_to_word(&mut cx, "naïve");
+
+ cx.assert_state("café résumé «naïveˇ»", Mode::HelixNormal);
+ assert_eq!(cx.active_operator(), None);
+ }
+
#[gpui::test]
async fn test_project_search_opens_in_normal_mode(cx: &mut gpui::TestAppContext) {
VimTestContext::init(cx);
diff --git a/crates/vim/src/state.rs b/crates/vim/src/state.rs
index 0442387c395..3bd4c0a5b80 100644
--- a/crates/vim/src/state.rs
+++ b/crates/vim/src/state.rs
@@ -155,6 +155,23 @@ pub enum Operator {
replaced_char: Option<char>,
},
HelixSurroundDelete,
+ HelixJump {
+ behaviour: HelixJumpBehaviour,
+ first_char: Option<char>,
+ labels: Vec<HelixJumpLabel>,
+ },
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct HelixJumpLabel {
+ pub label: [char; 2],
+ pub range: Range<Anchor>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum HelixJumpBehaviour {
+ Move,
+ Extend,
}
#[derive(Default, Clone, Debug)]
@@ -1085,6 +1102,7 @@ impl Operator {
Operator::HelixMatch => "helix_m",
Operator::HelixNext { .. } => "helix_next",
Operator::HelixPrevious { .. } => "helix_previous",
+ Operator::HelixJump { .. } => "gw",
Operator::HelixSurroundAdd => "helix_ms",
Operator::HelixSurroundReplace { .. } => "helix_mr",
Operator::HelixSurroundDelete => "helix_md",
@@ -1112,6 +1130,7 @@ impl Operator {
Operator::HelixMatch => "m".to_string(),
Operator::HelixNext { .. } => "]".to_string(),
Operator::HelixPrevious { .. } => "[".to_string(),
+ Operator::HelixJump { .. } => "gw".to_string(),
Operator::HelixSurroundAdd => "ms".to_string(),
Operator::HelixSurroundReplace {
replaced_char: None,
@@ -1142,7 +1161,8 @@ impl Operator {
| Operator::ChangeSurrounds {
target: Some(_), ..
}
- | Operator::DeleteSurrounds => true,
+ | Operator::DeleteSurrounds
+ | Operator::HelixJump { .. } => true,
Operator::Change
| Operator::Delete
| Operator::Yank
@@ -1213,7 +1233,8 @@ impl Operator {
| Operator::Register
| Operator::RecordRegister
| Operator::ReplayRegister
- | Operator::HelixMatch => false,
+ | Operator::HelixMatch
+ | Operator::HelixJump { .. } => false,
}
}
}
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index d9617d34ecf..a76846fd33d 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -23,7 +23,7 @@ use crate::normal::paste::Paste as VimPaste;
use collections::HashMap;
use editor::{
Anchor, Bias, Editor, EditorEvent, EditorSettings, HideMouseCursorOrigin, MultiBufferOffset,
- SelectionEffects,
+ NavigationOverlayKey, NavigationTargetOverlay, SelectionEffects,
actions::Paste,
display_map::ToDisplayPoint,
movement::{self, FindRange},
@@ -46,7 +46,9 @@ use settings::RegisterSetting;
pub use settings::{
ModeContent, Settings, SettingsStore, UseSystemClipboard, update_settings_file,
};
-use state::{Mode, Operator, RecordedSelection, SearchState, VimGlobals};
+use state::{
+ HelixJumpBehaviour, HelixJumpLabel, Mode, Operator, RecordedSelection, SearchState, VimGlobals,
+};
use std::{mem, ops::Range, sync::Arc};
use surrounds::SurroundsType;
use theme_settings::ThemeSettings;
@@ -60,6 +62,11 @@ use crate::{
state::ReplayableAction,
};
+enum HelixJumpNavigationOverlay {}
+
+pub(crate) const HELIX_JUMP_OVERLAY_KEY: NavigationOverlayKey =
+ NavigationOverlayKey::unique::<HelixJumpNavigationOverlay>();
+
/// Number is used to manage vim's count. Pushing a digit
/// multiplies the current value by 10 and adds the digit.
#[derive(Clone, Deserialize, JsonSchema, PartialEq, Action)]
@@ -1733,6 +1740,9 @@ impl Vim {
}
fn clear_operator(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+ if matches!(self.active_operator(), Some(Operator::HelixJump { .. })) {
+ self.clear_helix_jump_ui(window, cx);
+ }
Vim::take_count(cx);
Vim::take_forced_motion(cx);
self.selected_register.take();
@@ -1740,6 +1750,110 @@ impl Vim {
self.sync_vim_settings(window, cx);
}
+ fn clear_helix_jump_ui(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
+ self.update_editor(cx, move |_, editor, cx| {
+ editor.clear_navigation_overlays(HELIX_JUMP_OVERLAY_KEY, cx);
+ });
+ }
+
+ fn apply_helix_jump_ui(
+ &mut self,
+ overlays: Vec<NavigationTargetOverlay>,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) -> bool {
+ self.clear_helix_jump_ui(window, cx);
+ self.update_editor(cx, |_, editor, cx| {
+ editor.set_navigation_overlays(HELIX_JUMP_OVERLAY_KEY, overlays, cx);
+ })
+ .is_some()
+ }
+
+ fn handle_helix_jump_input(
+ &mut self,
+ operator: Operator,
+ input_char: char,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ let Operator::HelixJump {
+ behaviour,
+ first_char,
+ labels,
+ } = operator
+ else {
+ return;
+ };
+
+ let input = input_char.to_ascii_lowercase();
+ self.pop_operator(window, cx);
+
+ if let Some(first) = first_char {
+ let first = first.to_ascii_lowercase();
+ if let Some(candidate) = labels.into_iter().find(|label| {
+ label.label[0].eq_ignore_ascii_case(&first)
+ && label.label[1].eq_ignore_ascii_case(&input)
+ }) {
+ self.finish_helix_jump(candidate, behaviour, window, cx);
+ } else {
+ self.clear_helix_jump_ui(window, cx);
+ }
+ } else {
+ if !labels
+ .iter()
+ .any(|label| label.label[0].eq_ignore_ascii_case(&input))
+ {
+ self.clear_helix_jump_ui(window, cx);
+ return;
+ }
+
+ self.push_operator(
+ Operator::HelixJump {
+ behaviour,
+ first_char: Some(input),
+ labels,
+ },
+ window,
+ cx,
+ );
+ }
+ }
+
+ fn finish_helix_jump(
+ &mut self,
+ candidate: HelixJumpLabel,
+ behaviour: HelixJumpBehaviour,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ self.update_editor(cx, |_, editor, cx| match behaviour {
+ HelixJumpBehaviour::Move => {
+ editor.change_selections(Default::default(), window, cx, |s| {
+ s.select_anchor_ranges([candidate.range.clone()])
+ });
+ }
+ HelixJumpBehaviour::Extend => {
+ editor.change_selections(Default::default(), window, cx, |s| {
+ s.move_with(&mut |map, selection| {
+ let word_start = candidate.range.start.to_display_point(map);
+ let word_end = candidate.range.end.to_display_point(map);
+ let tail = selection.tail();
+
+ if word_start >= tail {
+ // Jumping forward: extend head to end of target word
+ selection.set_head(word_end, SelectionGoal::None);
+ } else {
+ // Jumping backward: extend backward while keeping current extent
+ // Use current end as tail to preserve the selection
+ selection.set_head_tail(word_start, selection.end, SelectionGoal::None);
+ }
+ });
+ });
+ }
+ });
+ self.clear_helix_jump_ui(window, cx);
+ }
+
fn active_operator(&self) -> Option<Operator> {
self.operator_stack.last().cloned()
}
@@ -1920,6 +2034,11 @@ impl Vim {
self.push_operator(Operator::SneakBackward { first_char }, window, cx);
}
}
+ Some(operator @ Operator::HelixJump { .. }) => {
+ if let Some(input_char) = text.chars().next() {
+ self.handle_helix_jump_input(operator, input_char, window, cx);
+ }
+ }
Some(Operator::Replace) => match self.mode {
Mode::Normal => self.normal_replace(text, window, cx),
Mode::Visual | Mode::VisualLine | Mode::VisualBlock => {