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.jsonindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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 => {