Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

vim: Handle exclusive-linewise edgecase correctly (#27786)

Browse source 
Before this change we didn't explicitly handle vim's exclusive-linewise
edgecase
(https://neovim.io/doc/user/motion.html#exclusive).

Instead we had hard-coded workarounds in a few places to make our tests
pass.
The most pernicious of these workarounds was that we represented a
visual line
selection as including the trailing newline (or leading newline for
files that
end with no newline), which other code had to undo to get back to what
the user
indended.

Closes #21440
Updates #6900

Release Notes:

- vim: Fixed `d]}` to not delete the closing brace
- vim: Fixed `d}` from the start of the line to not delete the paragraph
separator
- vim: Fixed `d}` from the middle of the line to not delete the final
newline
This commit is contained in:
Conrad Irwin 2025-03-31 10:36:20 -06:00 • committed by GitHub
parent e1e8c1786e
commit fc269dfaf9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
27 changed files with 471 additions and 482 deletions
Download patch file Download diff file Expand all files Collapse all files

15
crates/vim/src/normal/case.rs
View file

@ -37,7 +37,7 @@ impl Vim {
s.move_with(|map, selection| {
let anchor = map.display_point_to_anchor(selection.head(), Bias::Left);
selection_starts.insert(selection.id, anchor);
motion.expand_selection(map, selection, times, false, &text_layout_details);
motion.expand_selection(map, selection, times, &text_layout_details);
});
});
match mode {
@ -146,18 +146,9 @@ impl Vim {
let mut ranges = Vec::new();
let mut cursor_positions = Vec::new();
let snapshot = editor.buffer().read(cx).snapshot(cx);
for selection in editor.selections.all::<Point>(cx) {
for selection in editor.selections.all_adjusted(cx) {
match vim.mode {
Mode::VisualLine => {
let start = Point::new(selection.start.row, 0);
let end = Point::new(
selection.end.row,
snapshot.line_len(MultiBufferRow(selection.end.row)),
);
ranges.push(start..end);
cursor_positions.push(start..start);
}
Mode::Visual => {
Mode::Visual | Mode::VisualLine => {
ranges.push(selection.start..selection.end);
cursor_positions.push(selection.start..selection.start);
}

38
crates/vim/src/normal/change.rs
View file

@ -1,5 +1,5 @@
use crate::{
motion::{self, Motion},
motion::{self, Motion, MotionKind},
object::Object,
state::Mode,
Vim,
@ -22,14 +22,18 @@ impl Vim {
cx: &mut Context<Self>,
) {
// Some motions ignore failure when switching to normal mode
let mut motion_succeeded = matches!(
let mut motion_kind = if matches!(
motion,
Motion::Left
| Motion::Right
| Motion::EndOfLine { .. }
| Motion::WrappingLeft
| Motion::StartOfLine { .. }
);
) {
Some(MotionKind::Exclusive)
} else {
None
};
self.update_editor(window, cx, |vim, editor, window, cx| {
let text_layout_details = editor.text_layout_details(window);
editor.transact(window, cx, |editor, window, cx| {
@ -37,7 +41,7 @@ impl Vim {
editor.set_clip_at_line_ends(false, cx);
editor.change_selections(Some(Autoscroll::fit()), window, cx, |s| {
s.move_with(|map, selection| {
motion_succeeded |= match motion {
let kind = match motion {
Motion::NextWordStart { ignore_punctuation }
| Motion::NextSubwordStart { ignore_punctuation } => {
expand_changed_word_selection(
@ -50,11 +54,10 @@ impl Vim {
)
}
_ => {
let result = motion.expand_selection(
let kind = motion.expand_selection(
map,
selection,
times,
false,
&text_layout_details,
);
if let Motion::CurrentLine = motion {
@ -71,18 +74,23 @@ impl Vim {
}
selection.start = start_offset.to_display_point(map);
}
result
kind
}
};
if let Some(kind) = kind {
motion_kind.get_or_insert(kind);
}
});
});
vim.copy_selections_content(editor, motion.linewise(), window, cx);
editor.insert("", window, cx);
editor.refresh_inline_completion(true, false, window, cx);
if let Some(kind) = motion_kind {
vim.copy_selections_content(editor, kind, window, cx);
editor.insert("", window, cx);
editor.refresh_inline_completion(true, false, window, cx);
}
});
});
if motion_succeeded {
if motion_kind.is_some() {
self.switch_mode(Mode::Insert, false, window, cx)
} else {
self.switch_mode(Mode::Normal, false, window, cx)
@ -107,7 +115,7 @@ impl Vim {
});
});
if objects_found {
vim.copy_selections_content(editor, false, window, cx);
vim.copy_selections_content(editor, MotionKind::Exclusive, window, cx);
editor.insert("", window, cx);
editor.refresh_inline_completion(true, false, window, cx);
}
@ -135,7 +143,7 @@ fn expand_changed_word_selection(
ignore_punctuation: bool,
text_layout_details: &TextLayoutDetails,
use_subword: bool,
) -> bool {
) -> Option<MotionKind> {
let is_in_word = || {
let classifier = map
.buffer_snapshot
@ -166,14 +174,14 @@ fn expand_changed_word_selection(
selection.end = motion::next_char(map, selection.end, false);
}
}
true
Some(MotionKind::Inclusive)
} else {
let motion = if use_subword {
Motion::NextSubwordStart { ignore_punctuation }
} else {
Motion::NextWordStart { ignore_punctuation }
};
motion.expand_selection(map, selection, times, false, text_layout_details)
motion.expand_selection(map, selection, times, text_layout_details)
}
}

121
crates/vim/src/normal/delete.rs
View file

@ -1,4 +1,8 @@
use crate::{motion::Motion, object::Object, Vim};
use crate::{
motion::{Motion, MotionKind},
object::Object,
Vim,
};
use collections::{HashMap, HashSet};
use editor::{
display_map::{DisplaySnapshot, ToDisplayPoint},
@ -23,44 +27,41 @@ impl Vim {
editor.transact(window, cx, |editor, window, cx| {
editor.set_clip_at_line_ends(false, cx);
let mut original_columns: HashMap<_, _> = Default::default();
let mut motion_kind = None;
let mut ranges_to_copy = Vec::new();
editor.change_selections(Some(Autoscroll::fit()), window, cx, |s| {
s.move_with(|map, selection| {
let original_head = selection.head();
original_columns.insert(selection.id, original_head.column());
motion.expand_selection(map, selection, times, true, &text_layout_details);
let kind =
motion.expand_selection(map, selection, times, &text_layout_details);
let start_point = selection.start.to_point(map);
let next_line = map
.buffer_snapshot
.clip_point(Point::new(start_point.row + 1, 0), Bias::Left)
.to_display_point(map);
match motion {
// Motion::NextWordStart on an empty line should delete it.
Motion::NextWordStart { .. }
if selection.is_empty()
&& map
.buffer_snapshot
.line_len(MultiBufferRow(start_point.row))
== 0 =>
{
selection.end = next_line
ranges_to_copy
.push(selection.start.to_point(map)..selection.end.to_point(map));
// When deleting line-wise, we always want to delete a newline.
// If there is one after the current line, it goes; otherwise we
// pick the one before.
if kind == Some(MotionKind::Linewise) {
let start = selection.start.to_point(map);
let end = selection.end.to_point(map);
if end.row < map.buffer_snapshot.max_point().row {
selection.end = Point::new(end.row + 1, 0).to_display_point(map)
} else if start.row > 0 {
selection.start = Point::new(
start.row - 1,
map.buffer_snapshot.line_len(MultiBufferRow(start.row - 1)),
)
.to_display_point(map)
}
// Sentence motions, when done from start of line, include the newline
Motion::SentenceForward | Motion::SentenceBackward
if selection.start.column() == 0 =>
{
selection.end = next_line
}
Motion::EndOfDocument {} if times.is_none() => {
// Deleting until the end of the document includes the last line, including
// soft-wrapped lines.
selection.end = map.max_point()
}
_ => {}
}
if let Some(kind) = kind {
motion_kind.get_or_insert(kind);
}
});
});
vim.copy_selections_content(editor, motion.linewise(), window, cx);
let Some(kind) = motion_kind else { return };
vim.copy_ranges(editor, kind, false, ranges_to_copy, window, cx);
editor.insert("", window, cx);
// Fixup cursor position after the deletion
@ -68,7 +69,7 @@ impl Vim {
editor.change_selections(Some(Autoscroll::fit()), window, cx, |s| {
s.move_with(|map, selection| {
let mut cursor = selection.head();
if motion.linewise() {
if kind.linewise() {
if let Some(column) = original_columns.get(&selection.id) {
*cursor.column_mut() = *column
}
@ -148,7 +149,7 @@ impl Vim {
}
});
});
vim.copy_selections_content(editor, false, window, cx);
vim.copy_selections_content(editor, MotionKind::Exclusive, window, cx);
editor.insert("", window, cx);
// Fixup cursor position after the deletion
@ -654,36 +655,36 @@ mod test {
#[gpui::test]
async fn test_delete_sentence(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new(cx).await;
cx.simulate(
"d )",
indoc! {"
Fiˇrst. Second. Third.
Fourth.
"},
)
.await
.assert_matches();
// cx.simulate(
// "d )",
// indoc! {"
// Fiˇrst. Second. Third.
// Fourth.
// "},
// )
// .await
// .assert_matches();
cx.simulate(
"d )",
indoc! {"
First. Secˇond. Third.
Fourth.
"},
)
.await
.assert_matches();
// cx.simulate(
// "d )",
// indoc! {"
// First. Secˇond. Third.
// Fourth.
// "},
// )
// .await
// .assert_matches();
// Two deletes
cx.simulate(
"d ) d )",
indoc! {"
First. Second. Thirˇd.
Fourth.
"},
)
.await
.assert_matches();
// // Two deletes
// cx.simulate(
// "d ) d )",
// indoc! {"
// First. Second. Thirˇd.
// Fourth.
// "},
// )
// .await
// .assert_matches();
// Should delete whole line if done on first column
cx.simulate(

11
crates/vim/src/normal/paste.rs
View file

@ -6,7 +6,7 @@ use serde::Deserialize;
use std::cmp;
use crate::{
motion::Motion,
motion::{Motion, MotionKind},
object::Object,
state::{Mode, Register},
Vim,
@ -50,7 +50,7 @@ impl Vim {
.filter(|sel| sel.len() > 1 && vim.mode != Mode::VisualLine);
if !action.preserve_clipboard && vim.mode.is_visual() {
vim.copy_selections_content(editor, vim.mode == Mode::VisualLine, window, cx);
vim.copy_selections_content(editor, MotionKind::for_mode(vim.mode), window, cx);
}
let (display_map, current_selections) = editor.selections.all_adjusted_display(cx);
@ -118,8 +118,8 @@ impl Vim {
} else {
to_insert = "\n".to_owned() + &to_insert;
}
} else if !line_mode && vim.mode == Mode::VisualLine {
to_insert += "\n";
} else if line_mode && vim.mode == Mode::VisualLine {
to_insert.pop();
}
let display_range = if !selection.is_empty() {
@ -257,7 +257,7 @@ impl Vim {
editor.set_clip_at_line_ends(false, cx);
editor.change_selections(None, window, cx, |s| {
s.move_with(|map, selection| {
motion.expand_selection(map, selection, times, false, &text_layout_details);
motion.expand_selection(map, selection, times, &text_layout_details);
});
});
@ -537,6 +537,7 @@ mod test {
cx.shared_state().await.assert_eq(indoc! {"
The quick brown
the laˇzy dog"});
cx.shared_clipboard().await.assert_eq("fox jumps over\n");
// paste in visual line mode
cx.simulate_shared_keystrokes("k shift-v p").await;
cx.shared_state().await.assert_eq(indoc! {"

14
crates/vim/src/normal/substitute.rs
View file

@ -2,7 +2,10 @@ use editor::{movement, Editor};
use gpui::{actions, Context, Window};
use language::Point;
use crate::{motion::Motion, Mode, Vim};
use crate::{
motion::{Motion, MotionKind},
Mode, Vim,
};
actions!(vim, [Substitute, SubstituteLine]);
@ -43,7 +46,6 @@ impl Vim {
map,
selection,
count,
true,
&text_layout_details,
);
}
@ -57,7 +59,6 @@ impl Vim {
map,
selection,
None,
false,
&text_layout_details,
);
if let Some((point, _)) = (Motion::FirstNonWhitespace {
@ -75,7 +76,12 @@ impl Vim {
}
})
});
vim.copy_selections_content(editor, line_mode, window, cx);
let kind = if line_mode {
MotionKind::Linewise
} else {
MotionKind::Exclusive
};
vim.copy_selections_content(editor, kind, window, cx);
let selections = editor.selections.all::<Point>(cx).into_iter();
let edits = selections.map(|selection| (selection.start..selection.end, ""));
editor.edit(edits, cx);

2
crates/vim/src/normal/toggle_comments.rs
View file

@ -21,7 +21,7 @@ impl Vim {
s.move_with(|map, selection| {
let anchor = map.display_point_to_anchor(selection.head(), Bias::Right);
selection_starts.insert(selection.id, anchor);
motion.expand_selection(map, selection, times, false, &text_layout_details);
motion.expand_selection(map, selection, times, &text_layout_details);
});
});
editor.toggle_comments(&Default::default(), window, cx);

47
crates/vim/src/normal/yank.rs
View file

@ -1,7 +1,7 @@
use std::{ops::Range, time::Duration};
use crate::{
motion::Motion,
motion::{Motion, MotionKind},
object::Object,
state::{Mode, Register},
Vim, VimSettings,
@ -29,14 +29,16 @@ impl Vim {
editor.transact(window, cx, |editor, window, cx| {
editor.set_clip_at_line_ends(false, cx);
let mut original_positions: HashMap<_, _> = Default::default();
let mut kind = None;
editor.change_selections(None, window, cx, |s| {
s.move_with(|map, selection| {
let original_position = (selection.head(), selection.goal);
original_positions.insert(selection.id, original_position);
motion.expand_selection(map, selection, times, true, &text_layout_details);
});
kind = motion.expand_selection(map, selection, times, &text_layout_details);
})
});
vim.yank_selections_content(editor, motion.linewise(), window, cx);
let Some(kind) = kind else { return };
vim.yank_selections_content(editor, kind, window, cx);
editor.change_selections(None, window, cx, |s| {
s.move_with(|_, selection| {
let (head, goal) = original_positions.remove(&selection.id).unwrap();
@ -66,7 +68,7 @@ impl Vim {
start_positions.insert(selection.id, start_position);
});
});
vim.yank_selections_content(editor, false, window, cx);
vim.yank_selections_content(editor, MotionKind::Exclusive, window, cx);
editor.change_selections(None, window, cx, |s| {
s.move_with(|_, selection| {
let (head, goal) = start_positions.remove(&selection.id).unwrap();
@ -81,13 +83,13 @@ impl Vim {
pub fn yank_selections_content(
&mut self,
editor: &mut Editor,
linewise: bool,
kind: MotionKind,
window: &mut Window,
cx: &mut Context<Editor>,
) {
self.copy_ranges(
editor,
linewise,
kind,
true,
editor
.selections
@ -103,13 +105,13 @@ impl Vim {
pub fn copy_selections_content(
&mut self,
editor: &mut Editor,
linewise: bool,
kind: MotionKind,
window: &mut Window,
cx: &mut Context<Editor>,
) {
self.copy_ranges(
editor,
linewise,
kind,
false,
editor
.selections
@ -125,7 +127,7 @@ impl Vim {
pub(crate) fn copy_ranges(
&mut self,
editor: &mut Editor,
linewise: bool,
kind: MotionKind,
is_yank: bool,
selections: Vec<Range<Point>>,
window: &mut Window,
@ -160,7 +162,7 @@ impl Vim {
{
let mut is_first = true;
for selection in selections.iter() {
let mut start = selection.start;
let start = selection.start;
let end = selection.end;
if is_first {
is_first = false;
@ -169,23 +171,6 @@ impl Vim {
}
let initial_len = text.len();
// if the file does not end with \n, and our line-mode selection ends on
// that line, we will have expanded the start of the selection to ensure it
// contains a newline (so that delete works as expected). We undo that change
// here.
let max_point = buffer.max_point();
let should_adjust_start = linewise
&& end.row == max_point.row
&& max_point.column > 0
&& start.row < max_point.row
&& start == Point::new(start.row, buffer.line_len(MultiBufferRow(start.row)));
let should_add_newline =
should_adjust_start || (end == max_point && max_point.column > 0 && linewise);
if should_adjust_start {
start = Point::new(start.row + 1, 0);
}
let start_anchor = buffer.anchor_after(start);
let end_anchor = buffer.anchor_before(end);
ranges_to_highlight.push(start_anchor..end_anchor);
@ -193,12 +178,12 @@ impl Vim {
for chunk in buffer.text_for_range(start..end) {
text.push_str(chunk);
}
if should_add_newline {
if kind.linewise() {
text.push('\n');
}
clipboard_selections.push(ClipboardSelection {
len: text.len() - initial_len,
is_entire_line: linewise,
is_entire_line: kind.linewise(),
first_line_indent: buffer.indent_size_for_line(MultiBufferRow(start.row)).len,
});
}
@ -213,7 +198,7 @@ impl Vim {
},
selected_register,
is_yank,
linewise,
kind,
cx,
)
});