5 files changed, 54 insertions, 61 deletions

diff --git a/src/yellow/builder.rs b/src/yellow/builder.rs
index 65cc97ff9..0f7ca45d7 100644
--- a/src/yellow/builder.rs
+++ b/src/yellow/builder.rs
@@ -1,7 +1,7 @@
 use {
+    parser::Sink,
+    yellow::{GreenNode, GreenNodeBuilder, SyntaxError, SyntaxNode, SyntaxRoot},
     SyntaxKind, TextRange, TextUnit,
-    yellow::{SyntaxNode, SyntaxRoot, GreenNode, GreenNodeBuilder, SyntaxError},
-    parser::Sink
 };
 
 pub(crate) struct GreenBuilder {
@@ -12,9 +12,7 @@ pub(crate) struct GreenBuilder {
     errors: Vec<SyntaxError>,
 }
 
-impl GreenBuilder {
-
-}
+impl GreenBuilder {}
 
 impl Sink for GreenBuilder {
     type Tree = SyntaxNode;
@@ -53,7 +51,10 @@ impl Sink for GreenBuilder {
     }
 
     fn error(&mut self, message: String) {
-        self.errors.push(SyntaxError { message, offset: self.pos })
+        self.errors.push(SyntaxError {
+            message,
+            offset: self.pos,
+        })
     }
 
     fn finish(self) -> SyntaxNode {
@@ -61,5 +62,3 @@ impl Sink for GreenBuilder {
         SyntaxNode::new_owned(root)
     }
 }
-
-
diff --git a/src/yellow/green.rs b/src/yellow/green.rs
index cb9dff128..507e4d57e 100644
--- a/src/yellow/green.rs
+++ b/src/yellow/green.rs
@@ -1,5 +1,8 @@
 use std::sync::Arc;
-use {SyntaxKind::{self, *}, TextUnit};
+use {
+    SyntaxKind::{self, *},
+    TextUnit,
+};
 
 #[derive(Clone, Debug)]
 pub(crate) enum GreenNode {
@@ -36,9 +39,7 @@ impl GreenNode {
         fn go(node: &GreenNode, buff: &mut String) {
             match node {
                 GreenNode::Leaf(l) => buff.push_str(&l.text()),
-                GreenNode::Branch(b) => {
-                    b.children().iter().for_each(|child| go(child, buff))
-                }
+                GreenNode::Branch(b) => b.children().iter().for_each(|child| go(child, buff)),
             }
         }
     }
@@ -71,7 +72,6 @@ impl GreenNodeBuilder {
     }
 }
 
-
 #[test]
 fn assert_send_sync() {
     fn f<T: Send + Sync>() {}
@@ -80,14 +80,8 @@ fn assert_send_sync() {
 
 #[derive(Clone, Debug)]
 pub(crate) enum GreenLeaf {
-    Whitespace {
-        newlines: u8,
-        spaces: u8,
-    },
-    Token {
-        kind: SyntaxKind,
-        text: Arc<str>,
-    },
+    Whitespace { newlines: u8, spaces: u8 },
+    Token { kind: SyntaxKind, text: Arc<str> },
 }
 
 impl GreenLeaf {
@@ -96,10 +90,16 @@ impl GreenLeaf {
             let newlines = text.bytes().take_while(|&b| b == b'\n').count();
             let spaces = text[newlines..].bytes().take_while(|&b| b == b' ').count();
             if newlines + spaces == text.len() && newlines <= N_NEWLINES && spaces <= N_SPACES {
-                return GreenLeaf::Whitespace { newlines: newlines as u8, spaces: spaces as u8 };
+                return GreenLeaf::Whitespace {
+                    newlines: newlines as u8,
+                    spaces: spaces as u8,
+                };
             }
         }
-        GreenLeaf::Token { kind, text: text.to_owned().into_boxed_str().into() }
+        GreenLeaf::Token {
+            kind,
+            text: text.to_owned().into_boxed_str().into(),
+        }
     }
 
     pub(crate) fn kind(&self) -> SyntaxKind {
@@ -141,7 +141,11 @@ pub(crate) struct GreenBranch {
 impl GreenBranch {
     fn new(kind: SyntaxKind, children: Vec<GreenNode>) -> GreenBranch {
         let text_len = children.iter().map(|x| x.text_len()).sum::<TextUnit>();
-        GreenBranch { text_len, kind, children }
+        GreenBranch {
+            text_len,
+            kind,
+            children,
+        }
     }
 
     pub fn kind(&self) -> SyntaxKind {
@@ -156,4 +160,3 @@ impl GreenBranch {
         self.children.as_slice()
     }
 }
-
diff --git a/src/yellow/mod.rs b/src/yellow/mod.rs
index 89eefc98b..cada65d2f 100644
--- a/src/yellow/mod.rs
+++ b/src/yellow/mod.rs
@@ -1,12 +1,12 @@
+mod builder;
 mod green;
 mod red;
 mod syntax;
-mod builder;
 
+pub use self::syntax::{SyntaxNode, SyntaxNodeRef};
 pub(crate) use self::{
+    builder::GreenBuilder,
     green::{GreenNode, GreenNodeBuilder},
     red::RedNode,
     syntax::{SyntaxError, SyntaxRoot},
-    builder::GreenBuilder,
 };
-pub use self::syntax::{SyntaxNode, SyntaxNodeRef};
diff --git a/src/yellow/red.rs b/src/yellow/red.rs
index 3f0ddd04c..8907100e4 100644
--- a/src/yellow/red.rs
+++ b/src/yellow/red.rs
@@ -1,11 +1,5 @@
-use std::{
-    ptr,
-    sync::RwLock,
-};
-use {
-    TextUnit,
-    yellow::GreenNode,
-};
+use std::{ptr, sync::RwLock};
+use {yellow::GreenNode, TextUnit};
 
 #[derive(Debug)]
 pub(crate) struct RedNode {
@@ -22,9 +16,7 @@ struct ParentData {
 }
 
 impl RedNode {
-    pub fn new_root(
-        green: GreenNode,
-    ) -> RedNode {
+    pub fn new_root(green: GreenNode) -> RedNode {
         RedNode::new(green, None)
     }
 
@@ -42,13 +34,14 @@ impl RedNode {
         RedNode::new(green, Some(parent_data))
     }
 
-    fn new(
-        green: GreenNode,
-        parent: Option<ParentData>,
-    ) -> RedNode {
+    fn new(green: GreenNode, parent: Option<ParentData>) -> RedNode {
         let n_children = green.children().len();
         let children = (0..n_children).map(|_| None).collect();
-        RedNode { green, parent, children: RwLock::new(children) }
+        RedNode {
+            green,
+            parent,
+            children: RwLock::new(children),
+        }
     }
 
     pub(crate) fn green(&self) -> &GreenNode {
@@ -75,12 +68,15 @@ impl RedNode {
         if children[idx].is_none() {
             let green_children = self.green.children();
             let start_offset = self.start_offset()
-                + green_children[..idx].iter().map(|x| x.text_len()).sum::<TextUnit>();
-            let child = RedNode::new_child(green_children[idx].clone(), self.into(), start_offset, idx);
+                + green_children[..idx]
+                    .iter()
+                    .map(|x| x.text_len())
+                    .sum::<TextUnit>();
+            let child =
+                RedNode::new_child(green_children[idx].clone(), self.into(), start_offset, idx);
             children[idx] = Some(child)
         }
         children[idx].as_ref().unwrap().into()
-
     }
 
     pub(crate) fn parent(&self) -> Option<ptr::NonNull<RedNode>> {
diff --git a/src/yellow/syntax.rs b/src/yellow/syntax.rs
index 64af08236..19a9b8ac2 100644
--- a/src/yellow/syntax.rs
+++ b/src/yellow/syntax.rs
@@ -1,17 +1,12 @@
-use std::{
-    fmt,
-    sync::Arc,
-    ptr,
-    ops::Deref,
-};
+use std::{fmt, ops::Deref, ptr, sync::Arc};
 
 use {
-    TextRange, TextUnit,
+    yellow::{GreenNode, RedNode},
     SyntaxKind::{self, *},
-    yellow::{RedNode, GreenNode},
+    TextRange, TextUnit,
 };
 
-pub trait TreeRoot: Deref<Target=SyntaxRoot> + Clone {}
+pub trait TreeRoot: Deref<Target = SyntaxRoot> + Clone {}
 impl TreeRoot for Arc<SyntaxRoot> {}
 impl<'a> TreeRoot for &'a SyntaxRoot {}
 
@@ -50,7 +45,10 @@ impl SyntaxNode<Arc<SyntaxRoot>> {
     pub(crate) fn new_owned(root: SyntaxRoot) -> Self {
         let root = Arc::new(root);
         let red_weak = ptr::NonNull::from(&root.red);
-        SyntaxNode { root, red: red_weak }
+        SyntaxNode {
+            root,
+            red: red_weak,
+        }
     }
 }
 
@@ -68,10 +66,7 @@ impl<ROOT: TreeRoot> SyntaxNode<ROOT> {
 
     pub fn range(&self) -> TextRange {
         let red = self.red();
-        TextRange::offset_len(
-            red.start_offset(),
-            red.green().text_len(),
-        )
+        TextRange::offset_len(red.start_offset(), red.green().text_len())
     }
 
     pub fn text(&self) -> String {