Add count argument to motion functions and add ability to jump to a given line

crates/vim/src/motion.rs

@@ -155,31 +155,32 @@ impl Motion {
         map: &DisplaySnapshot,
         point: DisplayPoint,
         goal: SelectionGoal,
+        times: usize,
     ) -> (DisplayPoint, SelectionGoal) {
         use Motion::*;
         match self {
-            Left => (left(map, point), SelectionGoal::None),
+            Left => (left(map, point, times), SelectionGoal::None),
-            Backspace => (movement::left(map, point), SelectionGoal::None),
+            Backspace => (backspace(map, point, times), SelectionGoal::None),
-            Down => movement::down(map, point, goal, true),
+            Down => down(map, point, goal, times),
-            Up => movement::up(map, point, goal, true),
+            Up => up(map, point, goal, times),
-            Right => (right(map, point), SelectionGoal::None),
+            Right => (right(map, point, times), SelectionGoal::None),
             NextWordStart { ignore_punctuation } => (
-                next_word_start(map, point, ignore_punctuation),
+                next_word_start(map, point, ignore_punctuation, times),
                 SelectionGoal::None,
             ),
             NextWordEnd { ignore_punctuation } => (
-                next_word_end(map, point, ignore_punctuation),
+                next_word_end(map, point, ignore_punctuation, times),
                 SelectionGoal::None,
             ),
             PreviousWordStart { ignore_punctuation } => (
-                previous_word_start(map, point, ignore_punctuation),
+                previous_word_start(map, point, ignore_punctuation, times),
                 SelectionGoal::None,
             ),
             FirstNonWhitespace => (first_non_whitespace(map, point), SelectionGoal::None),
             StartOfLine => (start_of_line(map, point), SelectionGoal::None),
             EndOfLine => (end_of_line(map, point), SelectionGoal::None),
             CurrentLine => (end_of_line(map, point), SelectionGoal::None),
-            StartOfDocument => (start_of_document(map, point), SelectionGoal::None),
+            StartOfDocument => (start_of_document(map, point, times), SelectionGoal::None),
             EndOfDocument => (end_of_document(map, point), SelectionGoal::None),
             Matching => (matching(map, point), SelectionGoal::None),
         }
@@ -193,10 +194,8 @@ impl Motion {
         times: usize,
         expand_to_surrounding_newline: bool,
     ) {
-        for _ in 0..times {
+        let (head, goal) = self.move_point(map, selection.head(), selection.goal, times);
-            let (head, goal) = self.move_point(map, selection.head(), selection.goal);
+        selection.set_head(head, goal);
-            selection.set_head(head, goal);
-        }
 
         if self.linewise() {
             selection.start = map.prev_line_boundary(selection.start.to_point(map)).1;
@@ -243,77 +242,133 @@ impl Motion {
     }
 }
 
-fn left(map: &DisplaySnapshot, mut point: DisplayPoint) -> DisplayPoint {
+fn left(map: &DisplaySnapshot, mut point: DisplayPoint, times: usize) -> DisplayPoint {
-    *point.column_mut() = point.column().saturating_sub(1);
+    for _ in 0..times {
-    map.clip_point(point, Bias::Left)
+        *point.column_mut() = point.column().saturating_sub(1);
+        point = map.clip_point(point, Bias::Right);
+        if point.column() == 0 {
+            break;
+        }
+    }
+    point
 }
 
-pub(crate) fn right(map: &DisplaySnapshot, mut point: DisplayPoint) -> DisplayPoint {
+fn backspace(map: &DisplaySnapshot, mut point: DisplayPoint, times: usize) -> DisplayPoint {
-    *point.column_mut() += 1;
+    for _ in 0..times {
-    map.clip_point(point, Bias::Right)
+        point = movement::left(map, point);
+    }
+    point
+}
+
+fn down(
+    map: &DisplaySnapshot,
+    mut point: DisplayPoint,
+    mut goal: SelectionGoal,
+    times: usize,
+) -> (DisplayPoint, SelectionGoal) {
+    for _ in 0..times {
+        (point, goal) = movement::down(map, point, goal, true);
+    }
+    (point, goal)
+}
+
+fn up(
+    map: &DisplaySnapshot,
+    mut point: DisplayPoint,
+    mut goal: SelectionGoal,
+    times: usize,
+) -> (DisplayPoint, SelectionGoal) {
+    for _ in 0..times {
+        (point, goal) = movement::up(map, point, goal, true);
+    }
+    (point, goal)
+}
+
+pub(crate) fn right(map: &DisplaySnapshot, mut point: DisplayPoint, times: usize) -> DisplayPoint {
+    for _ in 0..times {
+        let mut new_point = point;
+        *new_point.column_mut() += 1;
+        let new_point = map.clip_point(new_point, Bias::Right);
+        if point == new_point {
+            break;
+        }
+        point = new_point;
+    }
+    point
 }
 
 pub(crate) fn next_word_start(
     map: &DisplaySnapshot,
-    point: DisplayPoint,
+    mut point: DisplayPoint,
     ignore_punctuation: bool,
+    times: usize,
 ) -> DisplayPoint {
-    let mut crossed_newline = false;
+    for _ in 0..times {
-    movement::find_boundary(map, point, |left, right| {
+        let mut crossed_newline = false;
-        let left_kind = char_kind(left).coerce_punctuation(ignore_punctuation);
+        point = movement::find_boundary(map, point, |left, right| {
-        let right_kind = char_kind(right).coerce_punctuation(ignore_punctuation);
+            let left_kind = char_kind(left).coerce_punctuation(ignore_punctuation);
-        let at_newline = right == '\n';
+            let right_kind = char_kind(right).coerce_punctuation(ignore_punctuation);
+            let at_newline = right == '\n';
 
-        let found = (left_kind != right_kind && right_kind != CharKind::Whitespace)
+            let found = (left_kind != right_kind && right_kind != CharKind::Whitespace)
-            || at_newline && crossed_newline
+                || at_newline && crossed_newline
-            || at_newline && left == '\n'; // Prevents skipping repeated empty lines
+                || at_newline && left == '\n'; // Prevents skipping repeated empty lines
 
-        if at_newline {
+            if at_newline {
-            crossed_newline = true;
+                crossed_newline = true;
-        }
+            }
-        found
+            found
-    })
+        })
+    }
+    point
 }
 
 fn next_word_end(
     map: &DisplaySnapshot,
     mut point: DisplayPoint,
     ignore_punctuation: bool,
+    times: usize,
 ) -> DisplayPoint {
-    *point.column_mut() += 1;
+    for _ in 0..times {
-    point = movement::find_boundary(map, point, |left, right| {
+        *point.column_mut() += 1;
-        let left_kind = char_kind(left).coerce_punctuation(ignore_punctuation);
+        point = movement::find_boundary(map, point, |left, right| {
-        let right_kind = char_kind(right).coerce_punctuation(ignore_punctuation);
+            let left_kind = char_kind(left).coerce_punctuation(ignore_punctuation);
+            let right_kind = char_kind(right).coerce_punctuation(ignore_punctuation);
 
-        left_kind != right_kind && left_kind != CharKind::Whitespace
+            left_kind != right_kind && left_kind != CharKind::Whitespace
-    });
+        });
 
-    // find_boundary clips, so if the character after the next character is a newline or at the end of the document, we know
+        // find_boundary clips, so if the character after the next character is a newline or at the end of the document, we know
-    // we have backtraced already
+        // we have backtraced already
-    if !map
+        if !map
-        .chars_at(point)
+            .chars_at(point)
-        .nth(1)
+            .nth(1)
-        .map(|(c, _)| c == '\n')
+            .map(|(c, _)| c == '\n')
-        .unwrap_or(true)
+            .unwrap_or(true)
-    {
+        {
-        *point.column_mut() = point.column().saturating_sub(1);
+            *point.column_mut() = point.column().saturating_sub(1);
+        }
+        point = map.clip_point(point, Bias::Left);
     }
-    map.clip_point(point, Bias::Left)
+    point
 }
 
 fn previous_word_start(
     map: &DisplaySnapshot,
     mut point: DisplayPoint,
     ignore_punctuation: bool,
+    times: usize,
 ) -> DisplayPoint {
-    // This works even though find_preceding_boundary is called for every character in the line containing
+    for _ in 0..times {
-    // cursor because the newline is checked only once.
+        // This works even though find_preceding_boundary is called for every character in the line containing
-    point = movement::find_preceding_boundary(map, point, |left, right| {
+        // cursor because the newline is checked only once.
-        let left_kind = char_kind(left).coerce_punctuation(ignore_punctuation);
+        point = movement::find_preceding_boundary(map, point, |left, right| {
-        let right_kind = char_kind(right).coerce_punctuation(ignore_punctuation);
+            let left_kind = char_kind(left).coerce_punctuation(ignore_punctuation);
+            let right_kind = char_kind(right).coerce_punctuation(ignore_punctuation);
 
-        (left_kind != right_kind && !right.is_whitespace()) || left == '\n'
+            (left_kind != right_kind && !right.is_whitespace()) || left == '\n'
-    });
+        });
+    }
     point
 }
 
@@ -342,8 +397,8 @@ fn end_of_line(map: &DisplaySnapshot, point: DisplayPoint) -> DisplayPoint {
     map.clip_point(map.next_line_boundary(point.to_point(map)).1, Bias::Left)
 }
 
-fn start_of_document(map: &DisplaySnapshot, point: DisplayPoint) -> DisplayPoint {
+fn start_of_document(map: &DisplaySnapshot, point: DisplayPoint, line: usize) -> DisplayPoint {
-    let mut new_point = 0usize.to_display_point(map);
+    let mut new_point = (line - 1).to_display_point(map);
     *new_point.column_mut() = point.column();
     map.clip_point(new_point, Bias::Left)
 }

crates/vim/src/normal.rs

@@ -115,13 +115,7 @@ pub fn normal_object(object: Object, cx: &mut MutableAppContext) {
 fn move_cursor(vim: &mut Vim, motion: Motion, times: usize, cx: &mut MutableAppContext) {
     vim.update_active_editor(cx, |editor, cx| {
         editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
-            s.move_cursors_with(|map, cursor, goal| {
+            s.move_cursors_with(|map, cursor, goal| motion.move_point(map, cursor, goal, times))
-                let mut result = (cursor, goal);
-                for _ in 0..times {
-                    result = motion.move_point(map, result.0, result.1);
-                }
-                result
-            })
         })
     });
 }
@@ -132,7 +126,7 @@ fn insert_after(_: &mut Workspace, _: &InsertAfter, cx: &mut ViewContext<Workspa
         vim.update_active_editor(cx, |editor, cx| {
             editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                 s.move_cursors_with(|map, cursor, goal| {
-                    Motion::Right.move_point(map, cursor, goal)
+                    Motion::Right.move_point(map, cursor, goal, 1)
                 });
             });
         });
@@ -149,7 +143,7 @@ fn insert_first_non_whitespace(
         vim.update_active_editor(cx, |editor, cx| {
             editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                 s.move_cursors_with(|map, cursor, goal| {
-                    Motion::FirstNonWhitespace.move_point(map, cursor, goal)
+                    Motion::FirstNonWhitespace.move_point(map, cursor, goal, 1)
                 });
             });
         });
@@ -162,7 +156,7 @@ fn insert_end_of_line(_: &mut Workspace, _: &InsertEndOfLine, cx: &mut ViewConte
         vim.update_active_editor(cx, |editor, cx| {
             editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                 s.move_cursors_with(|map, cursor, goal| {
-                    Motion::EndOfLine.move_point(map, cursor, goal)
+                    Motion::EndOfLine.move_point(map, cursor, goal, 1)
                 });
             });
         });
@@ -222,7 +216,7 @@ fn insert_line_below(_: &mut Workspace, _: &InsertLineBelow, cx: &mut ViewContex
                 });
                 editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
                     s.move_cursors_with(|map, cursor, goal| {
-                        Motion::EndOfLine.move_point(map, cursor, goal)
+                        Motion::EndOfLine.move_point(map, cursor, goal, 1)
                     });
                 });
                 editor.edit_with_autoindent(edits, cx);
@@ -551,19 +545,34 @@ mod test {
 
     #[gpui::test]
     async fn test_gg(cx: &mut gpui::TestAppContext) {
-        let mut cx = NeovimBackedTestContext::new(cx).await.binding(["g", "g"]);
+        let mut cx = NeovimBackedTestContext::new(cx).await;
-        cx.assert_all(indoc! {"
+        cx.assert_binding_matches_all(
-            The qˇuick
+            ["g", "g"],
-        
+            indoc! {"
-            brown fox jumps
+                The qˇuick
-            over ˇthe laˇzy dog"})
-            .await;
-        cx.assert(indoc! {"
             
-        
+                brown fox jumps
-            brown fox jumps
+                over ˇthe laˇzy dog"},
-            over the laˇzy dog"})
+        )
-            .await;
+        .await;
+        cx.assert_binding_matches(
+            ["g", "g"],
+            indoc! {"
+                
+            
+                brown fox jumps
+                over the laˇzy dog"},
+        )
+        .await;
+        cx.assert_binding_matches(
+            ["2", "g", "g"],
+            indoc! {"
+                
+                
+                brown fox juˇmps
+                over the lazydog"},
+        )
+        .await;
     }
 
     #[gpui::test]

crates/vim/src/normal/change.rs

@@ -1,5 +1,5 @@
 use crate::{motion::Motion, object::Object, state::Mode, utils::copy_selections_content, Vim};
-use editor::{char_kind, display_map::DisplaySnapshot, movement, Autoscroll, Bias, DisplayPoint};
+use editor::{char_kind, display_map::DisplaySnapshot, movement, Autoscroll, DisplayPoint};
 use gpui::MutableAppContext;
 use language::Selection;
 

crates/vim/src/object.rs

@@ -6,7 +6,7 @@ use language::Selection;
 use serde::Deserialize;
 use workspace::Workspace;
 
-use crate::{motion, normal::normal_object, state::Mode, visual::visual_object, Vim};
+use crate::{motion::right, normal::normal_object, state::Mode, visual::visual_object, Vim};
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum Object {
@@ -124,7 +124,7 @@ fn in_word(
     // Use motion::right so that we consider the character under the cursor when looking for the start
     let start = movement::find_preceding_boundary_in_line(
         map,
-        motion::right(map, relative_to),
+        right(map, relative_to, 1),
         |left, right| {
             char_kind(left).coerce_punctuation(ignore_punctuation)
                 != char_kind(right).coerce_punctuation(ignore_punctuation)
@@ -185,7 +185,7 @@ fn around_next_word(
     // Get the start of the word
     let start = movement::find_preceding_boundary_in_line(
         map,
-        motion::right(map, relative_to),
+        right(map, relative_to, 1),
         |left, right| {
             char_kind(left).coerce_punctuation(ignore_punctuation)
                 != char_kind(right).coerce_punctuation(ignore_punctuation)

crates/vim/src/visual.rs

@@ -30,11 +30,9 @@ pub fn visual_motion(motion: Motion, times: usize, cx: &mut MutableAppContext) {
                 s.move_with(|map, selection| {
                     let was_reversed = selection.reversed;
 
-                    for _ in 0..times {
+                    let (new_head, goal) =
-                        let (new_head, goal) =
+                        motion.move_point(map, selection.head(), selection.goal, times);
-                            motion.move_point(map, selection.head(), selection.goal);
+                    selection.set_head(new_head, goal);
-                        selection.set_head(new_head, goal);
-                    }
 
                     if was_reversed && !selection.reversed {
                         // Head was at the start of the selection, and now is at the end. We need to move the start

crates/vim/test_data/test_gg.json

@@ -1 +1 @@
-[{"Text":"The quick\n\nbrown fox jumps\nover the lazy dog"},{"Mode":"Normal"},{"Selection":{"start":[0,5],"end":[0,5]}},{"Mode":"Normal"},{"Text":"The quick\n\nbrown fox jumps\nover the lazy dog"},{"Mode":"Normal"},{"Selection":{"start":[0,5],"end":[0,5]}},{"Mode":"Normal"},{"Text":"The quick\n\nbrown fox jumps\nover the lazy dog"},{"Mode":"Normal"},{"Selection":{"start":[0,8],"end":[0,8]}},{"Mode":"Normal"},{"Text":"\n\nbrown fox jumps\nover the lazy dog"},{"Mode":"Normal"},{"Selection":{"start":[0,0],"end":[0,0]}},{"Mode":"Normal"}]
+[{"Text":"The quick\n\nbrown fox jumps\nover the lazy dog"},{"Mode":"Normal"},{"Selection":{"start":[0,5],"end":[0,5]}},{"Mode":"Normal"},{"Text":"The quick\n\nbrown fox jumps\nover the lazy dog"},{"Mode":"Normal"},{"Selection":{"start":[0,5],"end":[0,5]}},{"Mode":"Normal"},{"Text":"The quick\n\nbrown fox jumps\nover the lazy dog"},{"Mode":"Normal"},{"Selection":{"start":[0,8],"end":[0,8]}},{"Mode":"Normal"},{"Text":"\n\nbrown fox jumps\nover the lazy dog"},{"Mode":"Normal"},{"Selection":{"start":[0,0],"end":[0,0]}},{"Mode":"Normal"},{"Text":"\n\nbrown fox jumps\nover the lazydog"},{"Mode":"Normal"},{"Selection":{"start":[1,0],"end":[1,0]}},{"Mode":"Normal"}]