5 files changed, 179 insertions, 8 deletions

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<impl FnOnce() -> 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<SyntaxNodeRef> {
+    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<AtomEdit>,
+}
+
+#[derive(Debug)]
+pub struct AtomEdit {
+    pub delete: TextRange,
+    pub insert: String,
+}
+
+#[derive(Debug)]
+pub struct EditBuilder {
+    atoms: Vec<AtomEdit>
+}
+
+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<TextUnit> {
+        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<TextRange> {
+        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);
 }