vim: Add basic mark support

assets/keymaps/vim.json

@@ -117,6 +117,9 @@
           }
         }
       ],
+      "m": ["vim::PushOperator", "Mark"],
+      "'": ["vim::PushOperator", { "Jump": { "line": true } }],
+      "`": ["vim::PushOperator", { "Jump": { "line": false } }],
       ";": "vim::RepeatFind",
       ",": "vim::RepeatFindReversed",
       "ctrl-o": "pane::GoBack",

crates/vim/src/motion.rs

@@ -13,7 +13,7 @@ use std::ops::Range;
 use workspace::Workspace;
 
 use crate::{
-    normal::normal_motion,
+    normal::{mark, normal_motion},
     state::{Mode, Operator},
     surrounds::SurroundsType,
     utils::coerce_punctuation,
@@ -105,6 +105,10 @@ pub enum Motion {
         prior_selections: Vec<Range<Anchor>>,
         new_selections: Vec<Range<Anchor>>,
     },
+    Jump {
+        anchor: Anchor,
+        line: bool,
+    },
 }
 
 #[derive(Clone, Deserialize, PartialEq)]
@@ -469,6 +473,7 @@ impl Motion {
             | WindowTop
             | WindowMiddle
             | WindowBottom
+            | Jump { line: true, .. }
             | EndOfParagraph => true,
             EndOfLine { .. }
             | Matching
@@ -492,6 +497,7 @@ impl Motion {
             | FindBackward { .. }
             | RepeatFind { .. }
             | RepeatFindReversed { .. }
+            | Jump { line: false, .. }
             | ZedSearchResult { .. } => false,
         }
     }
@@ -531,7 +537,8 @@ impl Motion {
             | WindowMiddle
             | WindowBottom
             | NextLineStart
-            | ZedSearchResult { .. } => false,
+            | ZedSearchResult { .. }
+            | Jump { .. } => false,
         }
     }
 
@@ -570,6 +577,7 @@ impl Motion {
             | PreviousSubwordStart { .. }
             | FirstNonWhitespace { .. }
             | FindBackward { .. }
+            | Jump { .. }
             | ZedSearchResult { .. } => false,
             RepeatFind { last_find: motion } | RepeatFindReversed { last_find: motion } => {
                 motion.inclusive()
@@ -761,6 +769,7 @@ impl Motion {
             WindowTop => window_top(map, point, &text_layout_details, times - 1),
             WindowMiddle => window_middle(map, point, &text_layout_details),
             WindowBottom => window_bottom(map, point, &text_layout_details, times - 1),
+            Jump { line, anchor } => mark::jump_motion(map, *anchor, *line),
             ZedSearchResult { new_selections, .. } => {
                 // There will be only one selection, as
                 // Search::SelectNextMatch selects a single match.

crates/vim/src/normal.rs

@@ -2,6 +2,7 @@ mod case;
 mod change;
 mod delete;
 mod increment;
+pub(crate) mod mark;
 mod paste;
 pub(crate) mod repeat;
 mod scroll;

crates/vim/src/normal/mark.rs

@@ -0,0 +1,143 @@
+use std::{ops::Range, sync::Arc};
+
+use collections::HashSet;
+use editor::{
+    display_map::{DisplaySnapshot, ToDisplayPoint},
+    movement, Anchor, Bias, DisplayPoint,
+};
+use gpui::WindowContext;
+use language::SelectionGoal;
+
+use crate::{
+    motion::{self, Motion},
+    Vim,
+};
+
+pub fn create_mark(vim: &mut Vim, text: Arc<str>, tail: bool, cx: &mut WindowContext) {
+    let Some(anchors) = vim.update_active_editor(cx, |_, editor, _| {
+        editor
+            .selections
+            .disjoint_anchors()
+            .iter()
+            .map(|s| if tail { s.tail() } else { s.head() })
+            .collect::<Vec<_>>()
+    }) else {
+        return;
+    };
+
+    vim.update_state(|state| state.marks.insert(text.to_string(), anchors));
+    vim.clear_operator(cx);
+}
+
+pub fn create_mark_after(vim: &mut Vim, text: Arc<str>, cx: &mut WindowContext) {
+    let Some(anchors) = vim.update_active_editor(cx, |_, editor, cx| {
+        let (map, selections) = editor.selections.all_display(cx);
+        selections
+            .into_iter()
+            .map(|selection| {
+                let point = movement::saturating_right(&map, selection.tail());
+                map.buffer_snapshot
+                    .anchor_before(point.to_offset(&map, Bias::Left))
+            })
+            .collect::<Vec<_>>()
+    }) else {
+        return;
+    };
+
+    vim.update_state(|state| state.marks.insert(text.to_string(), anchors));
+    vim.clear_operator(cx);
+}
+
+pub fn create_mark_before(vim: &mut Vim, text: Arc<str>, cx: &mut WindowContext) {
+    let Some(anchors) = vim.update_active_editor(cx, |_, editor, cx| {
+        let (map, selections) = editor.selections.all_display(cx);
+        selections
+            .into_iter()
+            .map(|selection| {
+                let point = movement::saturating_left(&map, selection.head());
+                map.buffer_snapshot
+                    .anchor_before(point.to_offset(&map, Bias::Left))
+            })
+            .collect::<Vec<_>>()
+    }) else {
+        return;
+    };
+
+    vim.update_state(|state| state.marks.insert(text.to_string(), anchors));
+    vim.clear_operator(cx);
+}
+
+pub fn jump(text: Arc<str>, line: bool, cx: &mut WindowContext) {
+    let anchors = match &*text {
+        "{" | "}" => Vim::update(cx, |vim, cx| {
+            vim.update_active_editor(cx, |_, editor, cx| {
+                let (map, selections) = editor.selections.all_display(cx);
+                selections
+                    .into_iter()
+                    .map(|selection| {
+                        let point = if &*text == "{" {
+                            movement::start_of_paragraph(&map, selection.head(), 1)
+                        } else {
+                            movement::end_of_paragraph(&map, selection.head(), 1)
+                        };
+                        map.buffer_snapshot
+                            .anchor_before(point.to_offset(&map, Bias::Left))
+                    })
+                    .collect::<Vec<Anchor>>()
+            })
+        }),
+        _ => Vim::read(cx).state().marks.get(&*text).cloned(),
+    };
+
+    Vim::update(cx, |vim, cx| {
+        vim.pop_operator(cx);
+    });
+
+    let Some(anchors) = anchors else { return };
+
+    let is_active_operator = Vim::read(cx).state().active_operator().is_some();
+    if is_active_operator {
+        if let Some(anchor) = anchors.last() {
+            motion::motion(
+                Motion::Jump {
+                    anchor: *anchor,
+                    line,
+                },
+                cx,
+            )
+        }
+        return;
+    } else {
+        Vim::update(cx, |vim, cx| {
+            vim.update_active_editor(cx, |_, editor, cx| {
+                let map = editor.snapshot(cx);
+                let mut ranges: HashSet<Range<Anchor>> = HashSet::default();
+                for mut anchor in anchors {
+                    if line {
+                        let mut point = anchor.to_display_point(&map.display_snapshot);
+                        point = motion::first_non_whitespace(&map.display_snapshot, false, point);
+                        anchor = map
+                            .display_snapshot
+                            .buffer_snapshot
+                            .anchor_before(point.to_point(&map.display_snapshot));
+                    }
+                    ranges.insert(anchor..anchor);
+                }
+                editor.change_selections(None, cx, |s| s.select_anchor_ranges(ranges))
+            });
+        })
+    }
+}
+
+pub fn jump_motion(
+    map: &DisplaySnapshot,
+    anchor: Anchor,
+    line: bool,
+) -> (DisplayPoint, SelectionGoal) {
+    let mut point = anchor.to_display_point(map);
+    if line {
+        point = motion::first_non_whitespace(map, false, point)
+    }
+
+    (point, SelectionGoal::None)
+}

crates/vim/src/state.rs

@@ -59,6 +59,8 @@ pub enum Operator {
     AddSurrounds { target: Option<SurroundsType> },
     ChangeSurrounds { target: Option<Object> },
     DeleteSurrounds,
+    Mark,
+    Jump { line: bool },
 }
 
 #[derive(Default, Clone)]
@@ -74,6 +76,8 @@ pub struct EditorState {
     pub operator_stack: Vec<Operator>,
     pub replacements: Vec<(Range<editor::Anchor>, String)>,
 
+    pub marks: HashMap<String, Vec<Anchor>>,
+
     pub current_tx: Option<TransactionId>,
     pub current_anchor: Option<Selection<Anchor>>,
     pub undo_modes: HashMap<TransactionId, Mode>,
@@ -172,7 +176,10 @@ impl EditorState {
         }
         matches!(
             self.operator_stack.last(),
-            Some(Operator::FindForward { .. }) | Some(Operator::FindBackward { .. })
+            Some(Operator::FindForward { .. })
+                | Some(Operator::FindBackward { .. })
+                | Some(Operator::Mark)
+                | Some(Operator::Jump { .. })
         )
     }
 
@@ -254,13 +261,18 @@ impl Operator {
             Operator::AddSurrounds { .. } => "ys",
             Operator::ChangeSurrounds { .. } => "cs",
             Operator::DeleteSurrounds => "ds",
+            Operator::Mark => "m",
+            Operator::Jump { line: true } => "'",
+            Operator::Jump { line: false } => "`",
         }
     }
 
     pub fn context_flags(&self) -> &'static [&'static str] {
         match self {
             Operator::Object { .. } | Operator::ChangeSurrounds { target: None } => &["VimObject"],
             Operator::FindForward { .. }
+            | Operator::Mark
+            | Operator::Jump { .. }
             | Operator::FindBackward { .. }
             | Operator::Replace
             | Operator::AddSurrounds { target: Some(_) }