From 66be735aa98c32fb062d1c756fa9303ff2d13002 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 12 Aug 2018 18:50:16 +0300 Subject: flip comma --- crates/libeditor/Cargo.toml | 2 + crates/libeditor/src/code_actions.rs | 33 +++++++++++++ crates/libeditor/src/edit.rs | 93 ++++++++++++++++++++++++++++++++++++ crates/libeditor/src/lib.rs | 7 ++- crates/libeditor/tests/test.rs | 52 +++++++++++++++++--- 5 files changed, 179 insertions(+), 8 deletions(-) create mode 100644 crates/libeditor/src/code_actions.rs create mode 100644 crates/libeditor/src/edit.rs (limited to 'crates/libeditor') diff --git a/crates/libeditor/Cargo.toml b/crates/libeditor/Cargo.toml index d6423979b..fe688bc20 100644 --- a/crates/libeditor/Cargo.toml +++ b/crates/libeditor/Cargo.toml @@ -7,4 +7,6 @@ publish = false [dependencies] itertools = "0.7.8" superslice = "0.1.0" + libsyntax2 = { path = "../libsyntax2" } +assert_eq_text = { path = "../assert_eq_text" } diff --git a/crates/libeditor/src/code_actions.rs b/crates/libeditor/src/code_actions.rs new file mode 100644 index 000000000..7c9874588 --- /dev/null +++ b/crates/libeditor/src/code_actions.rs @@ -0,0 +1,33 @@ +use {TextUnit, File, EditBuilder, Edit}; +use libsyntax2::{ + ast::AstNode, + SyntaxKind::COMMA, + SyntaxNodeRef, + algo::{ + Direction, siblings, + find_leaf_at_offset, + }, +}; + +pub fn flip_comma<'a>(file: &'a File, offset: TextUnit) -> Option Edit + 'a> { + let syntax = file.syntax(); + let syntax = syntax.as_ref(); + + let comma = find_leaf_at_offset(syntax, offset).find(|leaf| leaf.kind() == COMMA)?; + let left = non_trivia_sibling(comma, Direction::Backward)?; + let right = non_trivia_sibling(comma, Direction::Forward)?; + Some(move || { + let mut edit = EditBuilder::new(); + edit.replace(left.range(), right.text()); + edit.replace(right.range(), left.text()); + edit.finish() + }) +} + +fn non_trivia_sibling(node: SyntaxNodeRef, direction: Direction) -> Option { + siblings(node, direction) + .skip(1) + .find(|node| !node.kind().is_trivia()) +} + + diff --git a/crates/libeditor/src/edit.rs b/crates/libeditor/src/edit.rs new file mode 100644 index 000000000..163ecf6de --- /dev/null +++ b/crates/libeditor/src/edit.rs @@ -0,0 +1,93 @@ +use {TextRange, TextUnit}; + +#[derive(Debug)] +pub struct Edit { + pub atoms: Vec, +} + +#[derive(Debug)] +pub struct AtomEdit { + pub delete: TextRange, + pub insert: String, +} + +#[derive(Debug)] +pub struct EditBuilder { + atoms: Vec +} + +impl EditBuilder { + pub fn new() -> EditBuilder { + EditBuilder { atoms: Vec::new() } + } + + pub fn replace(&mut self, range: TextRange, replacement: String) { + let range = self.translate(range); + self.atoms.push(AtomEdit { delete: range, insert: replacement }) + } + + pub fn delete(&mut self, range: TextRange) { + self.replace(range, String::new()); + } + + pub fn insert(&mut self, offset: TextUnit, text: String) { + self.replace(TextRange::offset_len(offset, 0.into()), text) + } + + pub fn finish(self) -> Edit { + Edit { atoms: self.atoms } + } + + fn translate(&self, range: TextRange) -> TextRange { + let mut range = range; + for atom in self.atoms.iter() { + range = atom.apply_to_range(range) + .expect("conflicting edits"); + } + range + } +} + +impl Edit { + pub fn apply(&self, text: &str) -> String { + let mut text = text.to_owned(); + for atom in self.atoms.iter() { + text = atom.apply(&text); + } + text + } +} + +impl AtomEdit { + fn apply(&self, text: &str) -> String { + let prefix = &text[ + TextRange::from_to(0.into(), self.delete.start()) + ]; + let suffix = &text[ + TextRange::from_to(self.delete.end(), TextUnit::of_str(text)) + ]; + let mut res = String::with_capacity(prefix.len() + self.insert.len() + suffix.len()); + res.push_str(prefix); + res.push_str(&self.insert); + res.push_str(suffix); + res + } + + fn apply_to_position(&self, pos: TextUnit) -> Option { + if pos <= self.delete.start() { + return Some(pos); + } + if pos < self.delete.end() { + return None; + } + Some(pos - self.delete.len() + TextUnit::of_str(&self.insert)) + } + + fn apply_to_range(&self, range: TextRange) -> Option { + Some(TextRange::from_to( + self.apply_to_position(range.start())?, + self.apply_to_position(range.end())?, + )) + } +} + diff --git a/crates/libeditor/src/lib.rs b/crates/libeditor/src/lib.rs index 013d27450..103f32190 100644 --- a/crates/libeditor/src/lib.rs +++ b/crates/libeditor/src/lib.rs @@ -1,9 +1,12 @@ extern crate libsyntax2; extern crate superslice; +extern crate itertools; mod extend_selection; mod symbols; mod line_index; +mod edit; +mod code_actions; use libsyntax2::{ ast::{self, NameOwner}, @@ -15,7 +18,9 @@ pub use libsyntax2::{File, TextRange, TextUnit}; pub use self::{ line_index::{LineIndex, LineCol}, extend_selection::extend_selection, - symbols::{FileSymbol, file_symbols} + symbols::{FileSymbol, file_symbols}, + edit::{EditBuilder, Edit}, + code_actions::{flip_comma}, }; #[derive(Debug)] diff --git a/crates/libeditor/tests/test.rs b/crates/libeditor/tests/test.rs index dedca49a4..369854fed 100644 --- a/crates/libeditor/tests/test.rs +++ b/crates/libeditor/tests/test.rs @@ -1,9 +1,16 @@ extern crate libeditor; +extern crate libsyntax2; extern crate itertools; +#[macro_use] +extern crate assert_eq_text; use std::fmt; use itertools::Itertools; -use libeditor::{File, highlight, runnables, extend_selection, TextRange, file_symbols}; +use libsyntax2::AstNode; +use libeditor::{ + File, TextUnit, TextRange, + highlight, runnables, extend_selection, file_symbols, flip_comma, +}; #[test] fn test_extend_selection() { @@ -27,13 +34,13 @@ fn main() {} "#); let hls = highlight(&file); dbg_eq( - &hls, r#"[HighlightedRange { range: [1; 11), tag: "comment" }, HighlightedRange { range: [12; 14), tag: "keyword" }, HighlightedRange { range: [15; 19), tag: "function" }, HighlightedRange { range: [29; 36), tag: "text" }, HighlightedRange { range: [38; 50), tag: "string" }, - HighlightedRange { range: [52; 54), tag: "literal" }]"# + HighlightedRange { range: [52; 54), tag: "literal" }]"#, + &hls, ); } @@ -51,10 +58,10 @@ fn test_foo() {} "#); let runnables = runnables(&file); dbg_eq( - &runnables, r#"[Runnable { range: [1; 13), kind: Bin }, Runnable { range: [15; 39), kind: Test { name: "test_foo" } }, Runnable { range: [41; 75), kind: Test { name: "test_foo" } }]"#, + &runnables, ) } @@ -76,7 +83,6 @@ const C: i32 = 92; "#); let symbols = file_symbols(&file); dbg_eq( - &symbols, r#"[FileSymbol { parent: None, name: "Foo", name_range: [8; 11), node_range: [1; 26), kind: STRUCT }, FileSymbol { parent: None, name: "m", name_range: [32; 33), node_range: [28; 53), kind: MODULE }, FileSymbol { parent: Some(1), name: "bar", name_range: [43; 46), node_range: [40; 51), kind: FUNCTION }, @@ -84,6 +90,19 @@ const C: i32 = 92; FileSymbol { parent: None, name: "T", name_range: [81; 82), node_range: [76; 88), kind: TYPE_ITEM }, FileSymbol { parent: None, name: "S", name_range: [96; 97), node_range: [89; 108), kind: STATIC_ITEM }, FileSymbol { parent: None, name: "C", name_range: [115; 116), node_range: [109; 127), kind: CONST_ITEM }]"#, + &symbols, + ) +} + +#[test] +fn test_swap_comma() { + check_modification( + "fn foo(x: i32,<|> y: Result<(), ()>) {}", + "fn foo(y: Result<(), ()>, x: i32) {}", + &|file, offset| { + let edit = flip_comma(file, offset).unwrap()(); + edit.apply(&file.syntax().text()) + }, ) } @@ -91,8 +110,27 @@ fn file(text: &str) -> File { File::parse(text) } -fn dbg_eq(actual: &impl fmt::Debug, expected: &str) { +fn dbg_eq(expected: &str, actual: &impl fmt::Debug) { let actual = format!("{:?}", actual); let expected = expected.lines().map(|l| l.trim()).join(" "); - assert_eq!(actual, expected); + assert_eq!(expected, actual); +} + +fn check_modification( + before: &str, + after: &str, + f: &impl Fn(&File, TextUnit) -> String, +) { + let cursor = "<|>"; + let cursor_pos = match before.find(cursor) { + None => panic!("before text should contain cursor marker"), + Some(pos) => pos, + }; + let mut text = String::with_capacity(before.len() - cursor.len()); + text.push_str(&before[..cursor_pos]); + text.push_str(&before[cursor_pos + cursor.len()..]); + let cursor_pos = TextUnit::from(cursor_pos as u32); + let file = file(&text); + let actual = f(&file, cursor_pos); + assert_eq_text!(after, &actual); } -- cgit v1.2.3