From bef2013c7fb94c71bee86dbe2aedb00a6b8153b5 Mon Sep 17 00:00:00 2001 From: Kay Simmons Date: Wed, 15 Feb 2023 14:28:14 -0800 Subject: [PATCH 1/5] wip --- .../src/test/editor_lsp_test_context.rs | 4 +- crates/vim/src/normal.rs | 9 +++++ crates/vim/src/test/vim_test_context.rs | 40 ++++++++++++++----- 3 files changed, 40 insertions(+), 13 deletions(-) diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs index 7f92190489a3958536f933cf00059fbc5290d1c3..89d59d853b5b827b33916bee2fe7ab26556566b6 100644 --- a/crates/editor/src/test/editor_lsp_test_context.rs +++ b/crates/editor/src/test/editor_lsp_test_context.rs @@ -62,7 +62,7 @@ impl<'a> EditorLspTestContext<'a> { params .fs .as_fake() - .insert_tree("/root", json!({ "dir": { file_name: "" }})) + .insert_tree("/root", json!({ "dir": { file_name.clone(): "" }})) .await; let (window_id, workspace) = cx.add_window(|cx| { @@ -107,7 +107,7 @@ impl<'a> EditorLspTestContext<'a> { }, lsp, workspace, - buffer_lsp_url: lsp::Url::from_file_path("/root/dir/file.rs").unwrap(), + buffer_lsp_url: lsp::Url::from_file_path(format!("/root/dir/{file_name}")).unwrap(), } } diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs index 742f2426c8aa6ba5d447eb0bcb7a8a2d92487762..f4d79ba89b4db946b5ce27086f619f7b57b53de6 100644 --- a/crates/vim/src/normal.rs +++ b/crates/vim/src/normal.rs @@ -1009,4 +1009,13 @@ mod test { .await; } } + + #[gpui::test] + async fn test_percent(cx: &mut gpui::TestAppContext) { + let mut cx = NeovimBackedTestContext::new(cx).await; + for count in 1..=2 { + // let test_case = indoc! {" + // "} + } + } } diff --git a/crates/vim/src/test/vim_test_context.rs b/crates/vim/src/test/vim_test_context.rs index 539ab0a8ff7f16f45700670065ae919d6160a427..4ac01c3f34ffa7ba6a775056639938636f2bf507 100644 --- a/crates/vim/src/test/vim_test_context.rs +++ b/crates/vim/src/test/vim_test_context.rs @@ -1,6 +1,8 @@ use std::ops::{Deref, DerefMut}; -use editor::test::editor_test_context::EditorTestContext; +use editor::test::{ + editor_lsp_test_context::EditorLspTestContext, editor_test_context::EditorTestContext, +}; use gpui::{json::json, AppContext, ContextHandle, ViewHandle}; use project::Project; use search::{BufferSearchBar, ProjectSearchBar}; @@ -11,7 +13,7 @@ use crate::{state::Operator, *}; use super::VimBindingTestContext; pub struct VimTestContext<'a> { - cx: EditorTestContext<'a>, + cx: EditorLspTestContext<'a>, workspace: ViewHandle, } @@ -26,19 +28,28 @@ impl<'a> VimTestContext<'a> { settings::KeymapFileContent::load("keymaps/vim.json", cx).unwrap(); }); - let params = cx.update(AppState::test); - let project = Project::test(params.fs.clone(), [], cx).await; - cx.update(|cx| { cx.update_global(|settings: &mut Settings, _| { settings.vim_mode = enabled; }); }); + let params = cx.update(AppState::test); + + let file_name = "test.rs"; + let mut fake_servers = language + .set_fake_lsp_adapter(Arc::new(FakeLspAdapter { + ..Default::default() + })) + .await; + + let project = Project::test(params.fs.clone(), [], cx).await; + project.update(cx, |project, _| project.languages().add(Arc::new(language))); + params .fs .as_fake() - .insert_tree("/root", json!({ "dir": { "test.txt": "" } })) + .insert_tree("/root", json!({ "dir": { "test.rs": "" } })) .await; let (window_id, workspace) = cx.add_window(|cx| { @@ -87,11 +98,18 @@ impl<'a> VimTestContext<'a> { }); editor.update(cx, |_, cx| cx.focus_self()); + let lsp = fake_servers.next().await.unwrap(); + Self { - cx: EditorTestContext { - cx, - window_id, - editor, + cx: EditorLspTestContext { + cx: EditorTestContext { + cx, + window_id, + editor, + }, + lsp, + workspace, + buffer_lsp_url: lsp::Url::from_file_path("/root/dir/file.rs").unwrap(), }, workspace, } @@ -101,7 +119,7 @@ impl<'a> VimTestContext<'a> { where F: FnOnce(&Workspace, &AppContext) -> T, { - self.workspace.read_with(self.cx.cx, read) + self.workspace.read_with(self.cx.cx.cx, read) } pub fn enable_vim(&mut self) { From eac33d732e1db3894d2f5a8e26346dcb25b63b18 Mon Sep 17 00:00:00 2001 From: Kay Simmons Date: Thu, 16 Feb 2023 12:23:45 -0800 Subject: [PATCH 2/5] wip --- crates/editor/src/multi_buffer.rs | 61 ++++++++------ .../src/test/editor_lsp_test_context.rs | 23 +++++- crates/language/src/buffer.rs | 6 +- crates/vim/src/normal.rs | 10 ++- crates/vim/src/test/vim_test_context.rs | 80 ++----------------- crates/vim/src/visual.rs | 2 +- 6 files changed, 73 insertions(+), 109 deletions(-) diff --git a/crates/editor/src/multi_buffer.rs b/crates/editor/src/multi_buffer.rs index 908e5c827d8558553ef4fc351b74d7deed31a314..7cc0031c4f746e7487a70f93d9ae6e41e35a8a12 100644 --- a/crates/editor/src/multi_buffer.rs +++ b/crates/editor/src/multi_buffer.rs @@ -385,9 +385,13 @@ impl MultiBuffer { _ => Default::default(), }; - #[allow(clippy::type_complexity)] - let mut buffer_edits: HashMap, Arc, bool, u32)>> = - Default::default(); + struct BufferEdit { + range: Range, + new_text: Arc, + is_insertion: bool, + original_indent_column: u32, + } + let mut buffer_edits: HashMap> = Default::default(); let mut cursor = snapshot.excerpts.cursor::(); for (ix, (range, new_text)) in edits.enumerate() { let new_text: Arc = new_text.into(); @@ -422,12 +426,12 @@ impl MultiBuffer { buffer_edits .entry(start_excerpt.buffer_id) .or_insert(Vec::new()) - .push(( - buffer_start..buffer_end, + .push(BufferEdit { + range: buffer_start..buffer_end, new_text, - true, + is_insertion: true, original_indent_column, - )); + }); } else { let start_excerpt_range = buffer_start ..start_excerpt @@ -444,21 +448,21 @@ impl MultiBuffer { buffer_edits .entry(start_excerpt.buffer_id) .or_insert(Vec::new()) - .push(( - start_excerpt_range, - new_text.clone(), - true, + .push(BufferEdit { + range: start_excerpt_range, + new_text: new_text.clone(), + is_insertion: true, original_indent_column, - )); + }); buffer_edits .entry(end_excerpt.buffer_id) .or_insert(Vec::new()) - .push(( - end_excerpt_range, - new_text.clone(), - false, + .push(BufferEdit { + range: end_excerpt_range, + new_text: new_text.clone(), + is_insertion: false, original_indent_column, - )); + }); cursor.seek(&range.start, Bias::Right, &()); cursor.next(&()); @@ -469,19 +473,19 @@ impl MultiBuffer { buffer_edits .entry(excerpt.buffer_id) .or_insert(Vec::new()) - .push(( - excerpt.range.context.to_offset(&excerpt.buffer), - new_text.clone(), - false, + .push(BufferEdit { + range: excerpt.range.context.to_offset(&excerpt.buffer), + new_text: new_text.clone(), + is_insertion: false, original_indent_column, - )); + }); cursor.next(&()); } } } for (buffer_id, mut edits) in buffer_edits { - edits.sort_unstable_by_key(|(range, _, _, _)| range.start); + edits.sort_unstable_by_key(|edit| edit.range.start); self.buffers.borrow()[&buffer_id] .buffer .update(cx, |buffer, cx| { @@ -490,14 +494,19 @@ impl MultiBuffer { let mut original_indent_columns = Vec::new(); let mut deletions = Vec::new(); let empty_str: Arc = "".into(); - while let Some(( + while let Some(BufferEdit { mut range, new_text, mut is_insertion, original_indent_column, - )) = edits.next() + }) = edits.next() { - while let Some((next_range, _, next_is_insertion, _)) = edits.peek() { + while let Some(BufferEdit { + range: next_range, + is_insertion: next_is_insertion, + .. + }) = edits.peek() + { if range.end >= next_range.start { range.end = cmp::max(next_range.end, range.end); is_insertion |= *next_is_insertion; diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs index 89d59d853b5b827b33916bee2fe7ab26556566b6..938de169a71c4400b2dec62609d19a30a6ed5b32 100644 --- a/crates/editor/src/test/editor_lsp_test_context.rs +++ b/crates/editor/src/test/editor_lsp_test_context.rs @@ -122,7 +122,26 @@ impl<'a> EditorLspTestContext<'a> { ..Default::default() }, Some(tree_sitter_rust::language()), - ); + ) + .with_queries(LanguageQueries { + indents: Some(Cow::from(indoc! {r#" + [ + ((where_clause) _ @end) + (field_expression) + (call_expression) + (assignment_expression) + (let_declaration) + (let_chain) + (await_expression) + ] @indent + + (_ "[" "]" @end) @indent + (_ "<" ">" @end) @indent + (_ "{" "}" @end) @indent + (_ "(" ")" @end) @indent"#})), + ..Default::default() + }) + .expect("Could not parse queries"); Self::new(language, capabilities, cx).await } @@ -148,7 +167,7 @@ impl<'a> EditorLspTestContext<'a> { ("\"" @open "\"" @close)"#})), ..Default::default() }) - .expect("Could not parse brackets"); + .expect("Could not parse queries"); Self::new(language, capabilities, cx).await } diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 953e059518c9c7e86259183293ce774c36a9d930..2119f86bbd943507e8a247aa80c50835adbc2c16 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -1389,12 +1389,12 @@ impl Buffer { .enumerate() .zip(&edit_operation.as_edit().unwrap().new_text) .map(|((ix, (range, _)), new_text)| { - let new_text_len = new_text.len(); + let new_text_length = new_text.len(); let old_start = range.start.to_point(&before_edit); let new_start = (delta + range.start as isize) as usize; - delta += new_text_len as isize - (range.end as isize - range.start as isize); + delta += new_text_length as isize - (range.end as isize - range.start as isize); - let mut range_of_insertion_to_indent = 0..new_text_len; + let mut range_of_insertion_to_indent = 0..new_text_length; let mut first_line_is_new = false; let mut original_indent_column = None; diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs index f4d79ba89b4db946b5ce27086f619f7b57b53de6..2dd2d489a507de67013b42f23fd47282ef4b80cd 100644 --- a/crates/vim/src/normal.rs +++ b/crates/vim/src/normal.rs @@ -857,13 +857,15 @@ mod test { // Our indentation is smarter than vims. So we don't match here cx.assert_manual( indoc! {" - fn test() - println!(ˇ);"}, + fn test() { + println!(ˇ); + }"}, Mode::Normal, indoc! {" - fn test() + fn test() { ˇ - println!();"}, + println!(); + }"}, Mode::Insert, ); cx.assert_manual( diff --git a/crates/vim/src/test/vim_test_context.rs b/crates/vim/src/test/vim_test_context.rs index 4ac01c3f34ffa7ba6a775056639938636f2bf507..f5614b4b474657deeef97041dfdcbe0c8cf6ef39 100644 --- a/crates/vim/src/test/vim_test_context.rs +++ b/crates/vim/src/test/vim_test_context.rs @@ -3,10 +3,8 @@ use std::ops::{Deref, DerefMut}; use editor::test::{ editor_lsp_test_context::EditorLspTestContext, editor_test_context::EditorTestContext, }; -use gpui::{json::json, AppContext, ContextHandle, ViewHandle}; -use project::Project; +use gpui::{AppContext, ContextHandle}; use search::{BufferSearchBar, ProjectSearchBar}; -use workspace::{pane, AppState, WorkspaceHandle}; use crate::{state::Operator, *}; @@ -14,56 +12,29 @@ use super::VimBindingTestContext; pub struct VimTestContext<'a> { cx: EditorLspTestContext<'a>, - workspace: ViewHandle, } impl<'a> VimTestContext<'a> { pub async fn new(cx: &'a mut gpui::TestAppContext, enabled: bool) -> VimTestContext<'a> { cx.update(|cx| { - editor::init(cx); - pane::init(cx); search::init(cx); crate::init(cx); settings::KeymapFileContent::load("keymaps/vim.json", cx).unwrap(); }); + let mut cx = EditorLspTestContext::new_rust(Default::default(), cx).await; + cx.update(|cx| { cx.update_global(|settings: &mut Settings, _| { settings.vim_mode = enabled; }); }); - let params = cx.update(AppState::test); - - let file_name = "test.rs"; - let mut fake_servers = language - .set_fake_lsp_adapter(Arc::new(FakeLspAdapter { - ..Default::default() - })) - .await; - - let project = Project::test(params.fs.clone(), [], cx).await; - project.update(cx, |project, _| project.languages().add(Arc::new(language))); - - params - .fs - .as_fake() - .insert_tree("/root", json!({ "dir": { "test.rs": "" } })) - .await; - - let (window_id, workspace) = cx.add_window(|cx| { - Workspace::new( - Default::default(), - 0, - project.clone(), - |_, _| unimplemented!(), - cx, - ) - }); + let window_id = cx.window_id; // Setup search toolbars and keypress hook - workspace.update(cx, |workspace, cx| { + cx.update_workspace(|workspace, cx| { observe_keystrokes(window_id, cx); workspace.active_pane().update(cx, |pane, cx| { pane.toolbar().update(cx, |toolbar, cx| { @@ -75,51 +46,14 @@ impl<'a> VimTestContext<'a> { }); }); - project - .update(cx, |project, cx| { - project.find_or_create_local_worktree("/root", true, cx) - }) - .await - .unwrap(); - cx.read(|cx| workspace.read(cx).worktree_scans_complete(cx)) - .await; - - let file = cx.read(|cx| workspace.file_project_paths(cx)[0].clone()); - let item = workspace - .update(cx, |workspace, cx| { - workspace.open_path(file, None, true, cx) - }) - .await - .expect("Could not open test file"); - - let editor = cx.update(|cx| { - item.act_as::(cx) - .expect("Opened test file wasn't an editor") - }); - editor.update(cx, |_, cx| cx.focus_self()); - - let lsp = fake_servers.next().await.unwrap(); - - Self { - cx: EditorLspTestContext { - cx: EditorTestContext { - cx, - window_id, - editor, - }, - lsp, - workspace, - buffer_lsp_url: lsp::Url::from_file_path("/root/dir/file.rs").unwrap(), - }, - workspace, - } + Self { cx } } pub fn workspace(&mut self, read: F) -> T where F: FnOnce(&Workspace, &AppContext) -> T, { - self.workspace.read_with(self.cx.cx.cx, read) + self.cx.workspace.read_with(self.cx.cx.cx, read) } pub fn enable_vim(&mut self) { diff --git a/crates/vim/src/visual.rs b/crates/vim/src/visual.rs index b890e4e41b503ad595cd3281a7cac533b67fc64f..2180fbdabb81ff3d991553c6771624d33f45a085 100644 --- a/crates/vim/src/visual.rs +++ b/crates/vim/src/visual.rs @@ -650,7 +650,7 @@ mod test { The quick brown the ˇfox jumps over - dog"}, + dog"}, Mode::Normal, ); } From 57a7ff9a6fce4797ebe13533d0ba911ff832fe31 Mon Sep 17 00:00:00 2001 From: Kay Simmons Date: Fri, 17 Feb 2023 14:52:36 -0800 Subject: [PATCH 3/5] fix vim percent motion to better match the docs and observed behavior --- crates/editor/src/multi_buffer.rs | 86 ++++++++++++------- .../src/test/editor_lsp_test_context.rs | 7 ++ crates/language/src/buffer.rs | 19 ++-- crates/language/src/buffer_tests.rs | 4 +- crates/vim/src/motion.rs | 58 ++++++++++--- crates/vim/src/normal.rs | 53 ++++++++---- crates/vim/test_data/test_o.json | 2 +- crates/vim/test_data/test_percent.json | 1 + 8 files changed, 151 insertions(+), 79 deletions(-) create mode 100644 crates/vim/test_data/test_percent.json diff --git a/crates/editor/src/multi_buffer.rs b/crates/editor/src/multi_buffer.rs index 7cc0031c4f746e7487a70f93d9ae6e41e35a8a12..ad661b84ee4850cfff27319fabaafa8844cde477 100644 --- a/crates/editor/src/multi_buffer.rs +++ b/crates/editor/src/multi_buffer.rs @@ -2630,6 +2630,9 @@ impl MultiBufferSnapshot { self.parse_count } + /// Returns the smallest enclosing bracket ranges containing the given range or + /// None if no brackets contain range or the range is not contained in a single + /// excerpt pub fn innermost_enclosing_bracket_ranges( &self, range: Range, @@ -2657,46 +2660,59 @@ impl MultiBufferSnapshot { result } - /// Returns enclosinng bracket ranges containing the given range or returns None if the range is + /// Returns enclosing bracket ranges containing the given range or returns None if the range is /// not contained in a single excerpt pub fn enclosing_bracket_ranges<'a, T: ToOffset>( &'a self, range: Range, ) -> Option, Range)> + 'a> { let range = range.start.to_offset(self)..range.end.to_offset(self); - self.excerpt_containing(range.clone()) - .map(|(excerpt, excerpt_offset)| { - let excerpt_buffer_start = excerpt.range.context.start.to_offset(&excerpt.buffer); - let excerpt_buffer_end = excerpt_buffer_start + excerpt.text_summary.len; - let start_in_buffer = - excerpt_buffer_start + range.start.saturating_sub(excerpt_offset); - let end_in_buffer = excerpt_buffer_start + range.end.saturating_sub(excerpt_offset); + self.bracket_ranges(range.clone()).map(|range_pairs| { + range_pairs + .filter(move |(open, close)| open.start <= range.start && close.end >= range.end) + }) + } - excerpt - .buffer - .enclosing_bracket_ranges(start_in_buffer..end_in_buffer) - .filter_map(move |(start_bracket_range, end_bracket_range)| { - if start_bracket_range.start < excerpt_buffer_start - || end_bracket_range.end > excerpt_buffer_end - { - return None; - } + /// Returns bracket range pairs overlapping the given `range` or returns None if the `range` is + /// not contained in a single excerpt + pub fn bracket_ranges<'a, T: ToOffset>( + &'a self, + range: Range, + ) -> Option, Range)> + 'a> { + let range = range.start.to_offset(self)..range.end.to_offset(self); + let excerpt = self.excerpt_containing(range.clone()); + excerpt.map(|(excerpt, excerpt_offset)| { + let excerpt_buffer_start = excerpt.range.context.start.to_offset(&excerpt.buffer); + let excerpt_buffer_end = excerpt_buffer_start + excerpt.text_summary.len; - let mut start_bracket_range = start_bracket_range.clone(); - start_bracket_range.start = - excerpt_offset + (start_bracket_range.start - excerpt_buffer_start); - start_bracket_range.end = - excerpt_offset + (start_bracket_range.end - excerpt_buffer_start); - - let mut end_bracket_range = end_bracket_range.clone(); - end_bracket_range.start = - excerpt_offset + (end_bracket_range.start - excerpt_buffer_start); - end_bracket_range.end = - excerpt_offset + (end_bracket_range.end - excerpt_buffer_start); - Some((start_bracket_range, end_bracket_range)) - }) - }) + let start_in_buffer = excerpt_buffer_start + range.start.saturating_sub(excerpt_offset); + let end_in_buffer = excerpt_buffer_start + range.end.saturating_sub(excerpt_offset); + + excerpt + .buffer + .bracket_ranges(start_in_buffer..end_in_buffer) + .filter_map(move |(start_bracket_range, end_bracket_range)| { + if start_bracket_range.start < excerpt_buffer_start + || end_bracket_range.end > excerpt_buffer_end + { + return None; + } + + let mut start_bracket_range = start_bracket_range.clone(); + start_bracket_range.start = + excerpt_offset + (start_bracket_range.start - excerpt_buffer_start); + start_bracket_range.end = + excerpt_offset + (start_bracket_range.end - excerpt_buffer_start); + + let mut end_bracket_range = end_bracket_range.clone(); + end_bracket_range.start = + excerpt_offset + (end_bracket_range.start - excerpt_buffer_start); + end_bracket_range.end = + excerpt_offset + (end_bracket_range.end - excerpt_buffer_start); + Some((start_bracket_range, end_bracket_range)) + }) + }) } pub fn diagnostics_update_count(&self) -> usize { @@ -2945,10 +2961,14 @@ impl MultiBufferSnapshot { let range = range.start.to_offset(self)..range.end.to_offset(self); let mut cursor = self.excerpts.cursor::(); - cursor.seek(&range.start, Bias::Right, &()); + cursor.seek(&dbg!(range.start), Bias::Right, &()); let start_excerpt = cursor.item(); - cursor.seek(&range.end, Bias::Right, &()); + if range.start == range.end { + return start_excerpt.map(|excerpt| (excerpt, *cursor.start())); + } + + cursor.seek(&dbg!(range.end), Bias::Right, &()); let end_excerpt = cursor.item(); start_excerpt diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs index 938de169a71c4400b2dec62609d19a30a6ed5b32..345709abf33f89862579cedd8482318063d0da6a 100644 --- a/crates/editor/src/test/editor_lsp_test_context.rs +++ b/crates/editor/src/test/editor_lsp_test_context.rs @@ -139,6 +139,13 @@ impl<'a> EditorLspTestContext<'a> { (_ "<" ">" @end) @indent (_ "{" "}" @end) @indent (_ "(" ")" @end) @indent"#})), + brackets: Some(Cow::from(indoc! {r#" + ("(" @open ")" @close) + ("[" @open "]" @close) + ("{" @open "}" @close) + ("<" @open ">" @close) + ("\"" @open "\"" @close) + (closure_parameters "|" @open "|" @close)"#})), ..Default::default() }) .expect("Could not parse queries"); diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 2119f86bbd943507e8a247aa80c50835adbc2c16..5f7dd9704994a7b6f145c4a902099a52f08bd74a 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -2346,18 +2346,18 @@ impl BufferSnapshot { Some(items) } - pub fn enclosing_bracket_ranges<'a, T: ToOffset>( + /// Returns bracket range pairs overlapping `range` + pub fn bracket_ranges<'a, T: ToOffset>( &'a self, range: Range, ) -> impl Iterator, Range)> + 'a { // Find bracket pairs that *inclusively* contain the given range. - let range = range.start.to_offset(self)..range.end.to_offset(self); + let range = range.start.to_offset(self).saturating_sub(1) + ..self.len().min(range.end.to_offset(self) + 1); - let mut matches = self.syntax.matches( - range.start.saturating_sub(1)..self.len().min(range.end + 1), - &self.text, - |grammar| grammar.brackets_config.as_ref().map(|c| &c.query), - ); + let mut matches = self.syntax.matches(range, &self.text, |grammar| { + grammar.brackets_config.as_ref().map(|c| &c.query) + }); let configs = matches .grammars() .iter() @@ -2380,11 +2380,6 @@ impl BufferSnapshot { matches.advance(); let Some((open, close)) = open.zip(close) else { continue }; - - if open.start > range.start || close.end < range.end { - continue; - } - return Some((open, close)); } None diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs index 4d2c9670c647bf0fb3e67c149d69dc1eee89792c..a24c7e227f608abc11b84fc5aecd9e428c9bb97f 100644 --- a/crates/language/src/buffer_tests.rs +++ b/crates/language/src/buffer_tests.rs @@ -2072,9 +2072,7 @@ fn assert_enclosing_bracket_pairs( .collect::>(); assert_set_eq!( - buffer - .enclosing_bracket_ranges(selection_range) - .collect::>(), + buffer.bracket_ranges(selection_range).collect::>(), bracket_pairs ); } diff --git a/crates/vim/src/motion.rs b/crates/vim/src/motion.rs index 7c821d6fec6a96e23c770d62cd9dafe51cea0483..25188a466cffa309bac6008dd854bdaf149482fb 100644 --- a/crates/vim/src/motion.rs +++ b/crates/vim/src/motion.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use editor::{ char_kind, display_map::{DisplaySnapshot, ToDisplayPoint}, - movement, Bias, CharKind, DisplayPoint, + movement, Bias, CharKind, DisplayPoint, ToOffset, }; use gpui::{actions, impl_actions, MutableAppContext}; use language::{Point, Selection, SelectionGoal}; @@ -450,19 +450,53 @@ fn end_of_document(map: &DisplaySnapshot, point: DisplayPoint, line: usize) -> D map.clip_point(new_point, Bias::Left) } -fn matching(map: &DisplaySnapshot, point: DisplayPoint) -> DisplayPoint { - let offset = point.to_offset(map, Bias::Left); - if let Some((open_range, close_range)) = map - .buffer_snapshot - .innermost_enclosing_bracket_ranges(offset..offset) - { - if open_range.contains(&offset) { - close_range.start.to_display_point(map) - } else { - open_range.start.to_display_point(map) +fn matching(map: &DisplaySnapshot, display_point: DisplayPoint) -> DisplayPoint { + // https://github.com/vim/vim/blob/1d87e11a1ef201b26ed87585fba70182ad0c468a/runtime/doc/motion.txt#L1200 + let point = display_point.to_point(map); + let offset = point.to_offset(&map.buffer_snapshot); + + // Ensure the range is contained by the current line. + let mut line_end = map.next_line_boundary(point).0; + if line_end == point { + line_end = map.max_point().to_point(map); + } + line_end.column = line_end.column.saturating_sub(1); + + let line_range = map.prev_line_boundary(point).0..line_end; + let ranges = map.buffer_snapshot.bracket_ranges(line_range.clone()); + if let Some(ranges) = ranges { + let line_range = line_range.start.to_offset(&map.buffer_snapshot) + ..line_range.end.to_offset(&map.buffer_snapshot); + let mut closest_pair_destination = None; + let mut closest_distance = usize::MAX; + + for (open_range, close_range) in ranges { + if open_range.start >= offset && line_range.contains(&open_range.start) { + let distance = open_range.start - offset; + if distance < closest_distance { + closest_pair_destination = Some(close_range.start); + closest_distance = distance; + continue; + } + } + + if close_range.start >= offset && line_range.contains(&close_range.start) { + let distance = close_range.start - offset; + if distance < closest_distance { + closest_pair_destination = Some(open_range.start); + closest_distance = distance; + continue; + } + } + + continue; } + + closest_pair_destination + .map(|destination| destination.to_display_point(map)) + .unwrap_or(display_point) } else { - point + display_point } } diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs index 2dd2d489a507de67013b42f23fd47282ef4b80cd..0cac45fd1859e3950ef38e733525702295cfd8c5 100644 --- a/crates/vim/src/normal.rs +++ b/crates/vim/src/normal.rs @@ -824,17 +824,34 @@ mod test { ˇ brown fox"}) .await; - cx.assert(indoc! {" + + cx.assert_manual( + indoc! {" fn test() { println!(ˇ); - } - "}) - .await; - cx.assert(indoc! {" + }"}, + Mode::Normal, + indoc! {" + fn test() { + println!(); + ˇ + }"}, + Mode::Insert, + ); + + cx.assert_manual( + indoc! {" fn test(ˇ) { println!(); - }"}) - .await; + }"}, + Mode::Normal, + indoc! {" + fn test() { + ˇ + println!(); + }"}, + Mode::Insert, + ); } #[gpui::test] @@ -996,14 +1013,14 @@ mod test { #[gpui::test] async fn test_capital_f_and_capital_t(cx: &mut gpui::TestAppContext) { let mut cx = NeovimBackedTestContext::new(cx).await; - for count in 1..=3 { - let test_case = indoc! {" - ˇaaaˇbˇ ˇbˇ ˇbˇbˇ aˇaaˇbaaa - ˇ ˇbˇaaˇa ˇbˇbˇb - ˇ - ˇb + let test_case = indoc! {" + ˇaaaˇbˇ ˇbˇ ˇbˇbˇ aˇaaˇbaaa + ˇ ˇbˇaaˇa ˇbˇbˇb + ˇ + ˇb "}; + for count in 1..=3 { cx.assert_binding_matches_all([&count.to_string(), "shift-f", "b"], test_case) .await; @@ -1014,10 +1031,10 @@ mod test { #[gpui::test] async fn test_percent(cx: &mut gpui::TestAppContext) { - let mut cx = NeovimBackedTestContext::new(cx).await; - for count in 1..=2 { - // let test_case = indoc! {" - // "} - } + let mut cx = NeovimBackedTestContext::new(cx).await.binding(["%"]); + cx.assert_all("ˇconsole.logˇ(ˇvaˇrˇ)ˇ;").await; + cx.assert_all("ˇconsole.logˇ(ˇ'var', ˇ[ˇ1, ˇ2, 3ˇ]ˇ)ˇ;") + .await; + cx.assert_all("let result = curried_funˇ(ˇ)ˇ(ˇ)ˇ;").await; } } diff --git a/crates/vim/test_data/test_o.json b/crates/vim/test_data/test_o.json index 08bea7cae82f3ac78bad1f16e46d43fb30799888..fa1a400bc0e2519b14c9da981a77575788f8b096 100644 --- a/crates/vim/test_data/test_o.json +++ b/crates/vim/test_data/test_o.json @@ -1 +1 @@ -[{"Text":"\n"},{"Mode":"Insert"},{"Selection":{"start":[1,0],"end":[1,0]}},{"Mode":"Insert"},{"Text":"The quick\n"},{"Mode":"Insert"},{"Selection":{"start":[1,0],"end":[1,0]}},{"Mode":"Insert"},{"Text":"The quick\n\nbrown fox\njumps over"},{"Mode":"Insert"},{"Selection":{"start":[1,0],"end":[1,0]}},{"Mode":"Insert"},{"Text":"The quick\nbrown fox\n\njumps over"},{"Mode":"Insert"},{"Selection":{"start":[2,0],"end":[2,0]}},{"Mode":"Insert"},{"Text":"The quick\nbrown fox\njumps over\n"},{"Mode":"Insert"},{"Selection":{"start":[3,0],"end":[3,0]}},{"Mode":"Insert"},{"Text":"The quick\n\n\nbrown fox"},{"Mode":"Insert"},{"Selection":{"start":[2,0],"end":[2,0]}},{"Mode":"Insert"},{"Text":"fn test() {\n println!();\n \n}\n"},{"Mode":"Insert"},{"Selection":{"start":[2,4],"end":[2,4]}},{"Mode":"Insert"},{"Text":"fn test() {\n\n println!();\n}"},{"Mode":"Insert"},{"Selection":{"start":[1,0],"end":[1,0]}},{"Mode":"Insert"}] \ No newline at end of file +[{"Text":"\n"},{"Mode":"Insert"},{"Selection":{"start":[1,0],"end":[1,0]}},{"Mode":"Insert"},{"Text":"The quick\n"},{"Mode":"Insert"},{"Selection":{"start":[1,0],"end":[1,0]}},{"Mode":"Insert"},{"Text":"The quick\n\nbrown fox\njumps over"},{"Mode":"Insert"},{"Selection":{"start":[1,0],"end":[1,0]}},{"Mode":"Insert"},{"Text":"The quick\nbrown fox\n\njumps over"},{"Mode":"Insert"},{"Selection":{"start":[2,0],"end":[2,0]}},{"Mode":"Insert"},{"Text":"The quick\nbrown fox\njumps over\n"},{"Mode":"Insert"},{"Selection":{"start":[3,0],"end":[3,0]}},{"Mode":"Insert"},{"Text":"The quick\n\n\nbrown fox"},{"Mode":"Insert"},{"Selection":{"start":[2,0],"end":[2,0]}},{"Mode":"Insert"}] \ No newline at end of file diff --git a/crates/vim/test_data/test_percent.json b/crates/vim/test_data/test_percent.json new file mode 100644 index 0000000000000000000000000000000000000000..9dc0fc655b266fea00a336785306c3afcd7ba2ae --- /dev/null +++ b/crates/vim/test_data/test_percent.json @@ -0,0 +1 @@ +[{"Text":"console.log(var);"},{"Mode":"Normal"},{"Selection":{"start":[0,15],"end":[0,15]}},{"Mode":"Normal"},{"Text":"console.log(var);"},{"Mode":"Normal"},{"Selection":{"start":[0,15],"end":[0,15]}},{"Mode":"Normal"},{"Text":"console.log(var);"},{"Mode":"Normal"},{"Selection":{"start":[0,11],"end":[0,11]}},{"Mode":"Normal"},{"Text":"console.log(var);"},{"Mode":"Normal"},{"Selection":{"start":[0,11],"end":[0,11]}},{"Mode":"Normal"},{"Text":"console.log(var);"},{"Mode":"Normal"},{"Selection":{"start":[0,11],"end":[0,11]}},{"Mode":"Normal"},{"Text":"console.log(var);"},{"Mode":"Normal"},{"Selection":{"start":[0,16],"end":[0,16]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,28],"end":[0,28]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,28],"end":[0,28]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,27],"end":[0,27]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,27],"end":[0,27]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,19],"end":[0,19]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,19],"end":[0,19]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,19],"end":[0,19]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,11],"end":[0,11]}},{"Mode":"Normal"},{"Text":"console.log('var', [1, 2, 3]);"},{"Mode":"Normal"},{"Selection":{"start":[0,29],"end":[0,29]}},{"Mode":"Normal"},{"Text":"let result = curried_fun()();"},{"Mode":"Normal"},{"Selection":{"start":[0,25],"end":[0,25]}},{"Mode":"Normal"},{"Text":"let result = curried_fun()();"},{"Mode":"Normal"},{"Selection":{"start":[0,24],"end":[0,24]}},{"Mode":"Normal"},{"Text":"let result = curried_fun()();"},{"Mode":"Normal"},{"Selection":{"start":[0,27],"end":[0,27]}},{"Mode":"Normal"},{"Text":"let result = curried_fun()();"},{"Mode":"Normal"},{"Selection":{"start":[0,26],"end":[0,26]}},{"Mode":"Normal"},{"Text":"let result = curried_fun()();"},{"Mode":"Normal"},{"Selection":{"start":[0,28],"end":[0,28]}},{"Mode":"Normal"}] \ No newline at end of file From 5e4d113308b658c1d1bef4dcfd9625e3b190ea6b Mon Sep 17 00:00:00 2001 From: Kay Simmons Date: Fri, 17 Feb 2023 17:19:23 -0800 Subject: [PATCH 4/5] fix bracket ranges failing test --- crates/language/src/buffer.rs | 10 ++++++++-- crates/language/src/buffer_tests.rs | 7 ++++--- crates/util/Cargo.toml | 2 +- crates/util/src/{lib.rs => util.rs} | 0 crates/workspace/src/workspace.rs | 19 ++++++++++++++++++- 5 files changed, 31 insertions(+), 7 deletions(-) rename crates/util/src/{lib.rs => util.rs} (100%) diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 5f7dd9704994a7b6f145c4a902099a52f08bd74a..857c0a063faa8323f327b3c5586e30a3ab30b8df 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -2346,7 +2346,7 @@ impl BufferSnapshot { Some(items) } - /// Returns bracket range pairs overlapping `range` + /// Returns bracket range pairs overlapping or adjacent to `range` pub fn bracket_ranges<'a, T: ToOffset>( &'a self, range: Range, @@ -2355,7 +2355,7 @@ impl BufferSnapshot { let range = range.start.to_offset(self).saturating_sub(1) ..self.len().min(range.end.to_offset(self) + 1); - let mut matches = self.syntax.matches(range, &self.text, |grammar| { + let mut matches = self.syntax.matches(range.clone(), &self.text, |grammar| { grammar.brackets_config.as_ref().map(|c| &c.query) }); let configs = matches @@ -2380,6 +2380,12 @@ impl BufferSnapshot { matches.advance(); let Some((open, close)) = open.zip(close) else { continue }; + + let bracket_range = open.start..=close.end; + if !bracket_range.contains(&range.start) && !bracket_range.contains(&range.end) { + continue; + } + return Some((open, close)); } None diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs index a24c7e227f608abc11b84fc5aecd9e428c9bb97f..e6e75447637296d4b78cab1b2d9f791882cc7d27 100644 --- a/crates/language/src/buffer_tests.rs +++ b/crates/language/src/buffer_tests.rs @@ -578,7 +578,7 @@ async fn test_symbols_containing(cx: &mut gpui::TestAppContext) { #[gpui::test] fn test_enclosing_bracket_ranges(cx: &mut MutableAppContext) { let mut assert = |selection_text, range_markers| { - assert_enclosing_bracket_pairs(selection_text, range_markers, rust_lang(), cx) + assert_bracket_pairs(selection_text, range_markers, rust_lang(), cx) }; assert( @@ -696,7 +696,7 @@ fn test_enclosing_bracket_ranges_where_brackets_are_not_outermost_children( cx: &mut MutableAppContext, ) { let mut assert = |selection_text, bracket_pair_texts| { - assert_enclosing_bracket_pairs(selection_text, bracket_pair_texts, javascript_lang(), cx) + assert_bracket_pairs(selection_text, bracket_pair_texts, javascript_lang(), cx) }; assert( @@ -710,6 +710,7 @@ fn test_enclosing_bracket_ranges_where_brackets_are_not_outermost_children( }"}], ); + eprintln!("-----------------------"); // Regression test: even though the parent node of the parentheses (the for loop) does // intersect the given range, the parentheses themselves do not contain the range, so // they should not be returned. Only the curly braces contain the range. @@ -2047,7 +2048,7 @@ fn get_tree_sexp(buffer: &ModelHandle, cx: &gpui::TestAppContext) -> Str } // Assert that the enclosing bracket ranges around the selection match the pairs indicated by the marked text in `range_markers` -fn assert_enclosing_bracket_pairs( +fn assert_bracket_pairs( selection_text: &'static str, bracket_pair_texts: Vec<&'static str>, language: Language, diff --git a/crates/util/Cargo.toml b/crates/util/Cargo.toml index 4cbaa382e84e3d099cc3a2aa2aa0276ce1f613f5..e8c158b637010d1faf3fbe2c0578f0f1fa82a0e7 100644 --- a/crates/util/Cargo.toml +++ b/crates/util/Cargo.toml @@ -5,6 +5,7 @@ edition = "2021" publish = false [lib] +path = "src/util.rs" doctest = false [features] @@ -22,7 +23,6 @@ serde_json = { version = "1.0", features = ["preserve_order"], optional = true } git2 = { version = "0.15", default-features = false, optional = true } dirs = "3.0" - [dev-dependencies] tempdir = { version = "0.3.7" } serde_json = { version = "1.0", features = ["preserve_order"] } diff --git a/crates/util/src/lib.rs b/crates/util/src/util.rs similarity index 100% rename from crates/util/src/lib.rs rename to crates/util/src/util.rs diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 8d81ae7f2ea97c5ec28b7bfff9da848c0004f765..95969de6b0b84d7692d6494d4026d40508619ae6 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -101,6 +101,7 @@ actions!( NewTerminal, NewSearch, Feedback, + Restart ] ); @@ -1329,7 +1330,19 @@ impl Workspace { focus_item: bool, cx: &mut ViewContext, ) -> Task, anyhow::Error>> { - let pane = pane.unwrap_or_else(|| self.active_pane().downgrade()); + let pane = pane.unwrap_or_else(|| { + if !self.dock_active() { + self.active_pane().downgrade() + } else { + self.last_active_center_pane.clone().unwrap_or_else(|| { + self.panes + .first() + .expect("There must be an active pane") + .downgrade() + }) + } + }); + let task = self.load_path(path.into(), cx); cx.spawn(|this, mut cx| async move { let (project_entry_id, build_item) = task.await?; @@ -1636,6 +1649,10 @@ impl Workspace { self.dock.pane() } + fn dock_active(&self) -> bool { + &self.active_pane == self.dock.pane() + } + fn project_remote_id_changed(&mut self, remote_id: Option, cx: &mut ViewContext) { if let Some(remote_id) = remote_id { self.remote_entity_subscription = From fc811d14b1c12a8fc5ae06483fe2f59d6110a237 Mon Sep 17 00:00:00 2001 From: Kay Simmons Date: Fri, 17 Feb 2023 22:00:39 -0800 Subject: [PATCH 5/5] Fix failing test --- crates/editor/src/editor.rs | 19 ++---------- crates/editor/src/multi_buffer.rs | 4 +-- crates/language/src/buffer.rs | 4 +-- crates/util/src/util.rs | 51 ++++++++++++++++++++++++++++--- 4 files changed, 52 insertions(+), 26 deletions(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 2cf0c9a36f5d2fcc3ac4776d11964ddd5e3ec49e..14566b9591c1fe8e0f6538c4929d912d7b167829 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -77,14 +77,14 @@ use std::{ cmp::{self, Ordering, Reverse}, mem, num::NonZeroU32, - ops::{Deref, DerefMut, Range, RangeInclusive}, + ops::{Deref, DerefMut, Range}, path::Path, sync::Arc, time::{Duration, Instant}, }; pub use sum_tree::Bias; use theme::{DiagnosticStyle, Theme}; -use util::{post_inc, ResultExt, TryFutureExt}; +use util::{post_inc, ResultExt, TryFutureExt, RangeExt}; use workspace::{ItemNavHistory, ViewId, Workspace, WorkspaceId}; use crate::git::diff_hunk_to_display; @@ -6959,21 +6959,6 @@ pub fn split_words<'a>(text: &'a str) -> impl std::iter::Iterator { - fn sorted(&self) -> Range; - fn to_inclusive(&self) -> RangeInclusive; -} - -impl RangeExt for Range { - fn sorted(&self) -> Self { - cmp::min(&self.start, &self.end).clone()..cmp::max(&self.start, &self.end).clone() - } - - fn to_inclusive(&self) -> RangeInclusive { - self.start.clone()..=self.end.clone() - } -} - trait RangeToAnchorExt { fn to_anchors(self, snapshot: &MultiBufferSnapshot) -> Range; } diff --git a/crates/editor/src/multi_buffer.rs b/crates/editor/src/multi_buffer.rs index ad661b84ee4850cfff27319fabaafa8844cde477..faf6787d00864c95a0e94b64ccdd18e9d3ea9416 100644 --- a/crates/editor/src/multi_buffer.rs +++ b/crates/editor/src/multi_buffer.rs @@ -2961,14 +2961,14 @@ impl MultiBufferSnapshot { let range = range.start.to_offset(self)..range.end.to_offset(self); let mut cursor = self.excerpts.cursor::(); - cursor.seek(&dbg!(range.start), Bias::Right, &()); + cursor.seek(&range.start, Bias::Right, &()); let start_excerpt = cursor.item(); if range.start == range.end { return start_excerpt.map(|excerpt| (excerpt, *cursor.start())); } - cursor.seek(&dbg!(range.end), Bias::Right, &()); + cursor.seek(&range.end, Bias::Right, &()); let end_excerpt = cursor.item(); start_excerpt diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 857c0a063faa8323f327b3c5586e30a3ab30b8df..00a754a7768aae91f2c9e21c45ee293a9107c1b6 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -41,7 +41,7 @@ pub use text::{Buffer as TextBuffer, BufferSnapshot as TextBufferSnapshot, Opera use theme::SyntaxTheme; #[cfg(any(test, feature = "test-support"))] use util::RandomCharIter; -use util::TryFutureExt as _; +use util::{RangeExt, TryFutureExt as _}; #[cfg(any(test, feature = "test-support"))] pub use {tree_sitter_rust, tree_sitter_typescript}; @@ -2382,7 +2382,7 @@ impl BufferSnapshot { let Some((open, close)) = open.zip(close) else { continue }; let bracket_range = open.start..=close.end; - if !bracket_range.contains(&range.start) && !bracket_range.contains(&range.end) { + if !bracket_range.overlaps(&range) { continue; } diff --git a/crates/util/src/util.rs b/crates/util/src/util.rs index ea8fdee2a8c5ded508581f7e7591e73f01ad4718..37e1f29ce280d457e3b3b1ded242333dce178676 100644 --- a/crates/util/src/util.rs +++ b/crates/util/src/util.rs @@ -3,16 +3,17 @@ pub mod paths; #[cfg(any(test, feature = "test-support"))] pub mod test; -pub use backtrace::Backtrace; -use futures::Future; -use rand::{seq::SliceRandom, Rng}; use std::{ - cmp::Ordering, - ops::AddAssign, + cmp::{self, Ordering}, + ops::{AddAssign, Range, RangeInclusive}, pin::Pin, task::{Context, Poll}, }; +pub use backtrace::Backtrace; +use futures::Future; +use rand::{seq::SliceRandom, Rng}; + #[derive(Debug, Default)] pub struct StaffMode(pub bool); @@ -245,6 +246,46 @@ macro_rules! async_iife { }; } +pub trait RangeExt { + fn sorted(&self) -> Self; + fn to_inclusive(&self) -> RangeInclusive; + fn overlaps(&self, other: &Range) -> bool; +} + +impl RangeExt for Range { + fn sorted(&self) -> Self { + cmp::min(&self.start, &self.end).clone()..cmp::max(&self.start, &self.end).clone() + } + + fn to_inclusive(&self) -> RangeInclusive { + self.start.clone()..=self.end.clone() + } + + fn overlaps(&self, other: &Range) -> bool { + self.contains(&other.start) + || self.contains(&other.end) + || other.contains(&self.start) + || other.contains(&self.end) + } +} + +impl RangeExt for RangeInclusive { + fn sorted(&self) -> Self { + cmp::min(self.start(), self.end()).clone()..=cmp::max(self.start(), self.end()).clone() + } + + fn to_inclusive(&self) -> RangeInclusive { + self.clone() + } + + fn overlaps(&self, other: &Range) -> bool { + self.contains(&other.start) + || self.contains(&other.end) + || other.contains(&self.start()) + || other.contains(&self.end()) + } +} + #[cfg(test)] mod tests { use super::*;