flip comma

5 files changed, 62 insertions, 49 deletions

diff --git a/crates/libsyntax2/Cargo.toml b/crates/libsyntax2/Cargo.toml
index 5a76ea82b..4c4040fe5 100644
--- a/crates/libsyntax2/Cargo.toml
+++ b/crates/libsyntax2/Cargo.toml
@@ -12,4 +12,4 @@ drop_bomb = "0.1.4"
 parking_lot = "0.6.0"
 
 [dev-dependencies]
-difference = "2.0.0"
+assert_eq_text = { path = "../assert_eq_text" }
diff --git a/crates/libsyntax2/src/algo/mod.rs b/crates/libsyntax2/src/algo/mod.rs
index 263b58d97..6efdff12f 100644
--- a/crates/libsyntax2/src/algo/mod.rs
+++ b/crates/libsyntax2/src/algo/mod.rs
@@ -74,7 +74,6 @@ impl<'f> Iterator for LeafAtOffset<'f> {
     }
 }
 
-
 pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRef {
     assert!(is_subrange(root.range(), range));
     let (left, right) = match (
@@ -88,31 +87,33 @@ pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRe
     common_ancestor(left, right)
 }
 
-fn common_ancestor<'a>(n1: SyntaxNodeRef<'a>, n2: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a> {
-    for p in ancestors(n1) {
-        if ancestors(n2).any(|a| a == p) {
-            return p;
-        }
-    }
-    panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
-}
-
 pub fn ancestors<'a>(node: SyntaxNodeRef<'a>) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
-    Ancestors(Some(node))
+    generate(Some(node), |&node| node.parent())
 }
 
 #[derive(Debug)]
-struct Ancestors<'a>(Option<SyntaxNodeRef<'a>>);
+pub enum Direction {
+    Forward,
+    Backward,
+}
 
-impl<'a> Iterator for Ancestors<'a> {
-    type Item = SyntaxNodeRef<'a>;
+pub fn siblings<'a>(
+    node: SyntaxNodeRef<'a>,
+    direction: Direction
+) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
+    generate(Some(node), move |&node| match direction {
+        Direction::Forward => node.next_sibling(),
+        Direction::Backward => node.prev_sibling(),
+    })
+}
 
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.take().map(|n| {
-            self.0 = n.parent();
-            n
-        })
+fn common_ancestor<'a>(n1: SyntaxNodeRef<'a>, n2: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a> {
+    for p in ancestors(n1) {
+        if ancestors(n2).any(|a| a == p) {
+            return p;
+        }
     }
+    panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
 }
 
 fn contains_offset_nonstrict(range: TextRange, offset: TextUnit) -> bool {
@@ -122,3 +123,12 @@ fn contains_offset_nonstrict(range: TextRange, offset: TextUnit) -> bool {
 fn is_subrange(range: TextRange, subrange: TextRange) -> bool {
     range.start() <= subrange.start() && subrange.end() <= range.end()
 }
+
+fn generate<T>(seed: Option<T>, step: impl Fn(&T) -> Option<T>) -> impl Iterator<Item=T> {
+    ::itertools::unfold(seed, move |slot| {
+        slot.take().map(|curr| {
+            *slot = step(&curr);
+            curr
+        })
+    })
+}
diff --git a/crates/libsyntax2/src/syntax_kinds/mod.rs b/crates/libsyntax2/src/syntax_kinds/mod.rs
index ed4fa5d4d..332cd13ac 100644
--- a/crates/libsyntax2/src/syntax_kinds/mod.rs
+++ b/crates/libsyntax2/src/syntax_kinds/mod.rs
@@ -17,7 +17,7 @@ pub(crate) struct SyntaxInfo {
 }
 
 impl SyntaxKind {
-    pub(crate) fn is_trivia(self) -> bool {
+    pub fn is_trivia(self) -> bool {
         match self {
             WHITESPACE | COMMENT | DOC_COMMENT => true,
             _ => false,
diff --git a/crates/libsyntax2/src/yellow/syntax.rs b/crates/libsyntax2/src/yellow/syntax.rs
index a22275ed9..00f76e51c 100644
--- a/crates/libsyntax2/src/yellow/syntax.rs
+++ b/crates/libsyntax2/src/yellow/syntax.rs
@@ -101,6 +101,17 @@ impl<R: TreeRoot> SyntaxNode<R> {
         })
     }
 
+    pub fn prev_sibling(&self) -> Option<SyntaxNode<R>> {
+        let red = self.red();
+        let parent = self.parent()?;
+        let prev_sibling_idx = red.index_in_parent()?.checked_sub(1)?;
+        let sibling_red = parent.red().get_child(prev_sibling_idx)?;
+        Some(SyntaxNode {
+            root: self.root.clone(),
+            red: sibling_red,
+        })
+    }
+
     pub fn is_leaf(&self) -> bool {
         self.first_child().is_none()
     }
diff --git a/crates/libsyntax2/tests/test/main.rs b/crates/libsyntax2/tests/test/main.rs
index 18e5bc4d4..64d080dfd 100644
--- a/crates/libsyntax2/tests/test/main.rs
+++ b/crates/libsyntax2/tests/test/main.rs
@@ -1,5 +1,6 @@
 extern crate libsyntax2;
-extern crate difference;
+#[macro_use]
+extern crate assert_eq_text;
 
 use std::{
     fs,
@@ -7,8 +8,6 @@ use std::{
     fmt::Write,
 };
 
-use difference::Changeset;
-
 #[test]
 fn lexer_tests() {
     dir_tests(&["lexer"], |text| {
@@ -63,10 +62,26 @@ pub fn dir_tests<F>(paths: &[&str], f: F)
     }
 }
 
+const REWRITE: bool = false;
+
 fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
-    if expected != actual {
-        print_difference(expected, actual, path)
+    if expected == actual {
+        return;
+    }
+    let dir = project_dir();
+    let path = path.strip_prefix(&dir).unwrap_or_else(|_| path);
+    if expected.trim() == actual.trim() {
+        println!("whitespace difference, rewriting");
+        println!("file: {}\n", path.display());
+        fs::write(path, actual).unwrap();
+        return;
+    }
+    if REWRITE {
+        println!("rewriting {}", path.display());
+        fs::write(path, actual).unwrap();
+        return;
     }
+    assert_eq_text!(expected, actual, "file: {}", path.display());
 }
 
 fn collect_tests(paths: &[&str]) -> Vec<PathBuf> {
@@ -92,29 +107,6 @@ fn test_from_dir(dir: &Path) -> Vec<PathBuf> {
     acc
 }
 
-const REWRITE: bool = false;
-
-fn print_difference(expected: &str, actual: &str, path: &Path) {
-    let dir = project_dir();
-    let path = path.strip_prefix(&dir).unwrap_or_else(|_| path);
-    if expected.trim() == actual.trim() {
-        println!("whitespace difference, rewriting");
-        println!("file: {}\n", path.display());
-        fs::write(path, actual).unwrap();
-        return;
-    }
-    if REWRITE {
-        println!("rewriting {}", path.display());
-        fs::write(path, actual).unwrap();
-        return;
-    }
-    let changeset = Changeset::new(actual, expected, "\n");
-    println!("Expected:\n{}\n\nActual:\n{}\n", expected, actual);
-    print!("{}", changeset);
-    println!("file: {}\n", path.display());
-    panic!("Comparison failed")
-}
-
 fn project_dir() -> PathBuf {
     let dir = env!("CARGO_MANIFEST_DIR");
     PathBuf::from(dir)