3 files changed, 33 insertions, 38 deletions

diff --git a/crates/ra_syntax/src/yellow/builder.rs b/crates/ra_syntax/src/yellow/builder.rs
index 67a1a382b..d64053409 100644
--- a/crates/ra_syntax/src/yellow/builder.rs
+++ b/crates/ra_syntax/src/yellow/builder.rs
@@ -1,10 +1,9 @@
-use rowan::GreenNodeBuilder;
 use crate::{
-    TextUnit, SmolStr,
     parser_impl::Sink,
-    yellow::{GreenNode, SyntaxError, RaTypes},
-    SyntaxKind,
+    yellow::{GreenNode, RaTypes, SyntaxError},
+    SmolStr, SyntaxKind, TextUnit,
 };
+use rowan::GreenNodeBuilder;
 
 pub(crate) struct GreenBuilder {
     errors: Vec<SyntaxError>,
@@ -36,7 +35,10 @@ impl Sink for GreenBuilder {
     }
 
     fn error(&mut self, message: String, offset: TextUnit) {
-        let error = SyntaxError { msg: message, offset };
+        let error = SyntaxError {
+            msg: message,
+            offset,
+        };
         self.errors.push(error)
     }
 
diff --git a/crates/ra_syntax/src/yellow/mod.rs b/crates/ra_syntax/src/yellow/mod.rs
index ab9bca0f0..b5c9da813 100644
--- a/crates/ra_syntax/src/yellow/mod.rs
+++ b/crates/ra_syntax/src/yellow/mod.rs
@@ -1,16 +1,16 @@
 mod builder;
 mod syntax_text;
 
+use self::syntax_text::SyntaxText;
+use crate::{SmolStr, SyntaxKind, TextRange, TextUnit};
+use rowan::Types;
 use std::{
     fmt,
     hash::{Hash, Hasher},
 };
-use rowan::Types;
-use crate::{SyntaxKind, TextUnit, TextRange, SmolStr};
-use self::syntax_text::SyntaxText;
 
-pub use rowan::{TreeRoot};
 pub(crate) use self::builder::GreenBuilder;
+pub use rowan::TreeRoot;
 
 #[derive(Debug, Clone, Copy)]
 pub enum RaTypes {}
@@ -31,9 +31,7 @@ pub struct SyntaxError {
 }
 
 #[derive(Clone, Copy)]
-pub struct SyntaxNode<R: TreeRoot<RaTypes> = OwnedRoot>(
-    ::rowan::SyntaxNode<RaTypes, R>,
-);
+pub struct SyntaxNode<R: TreeRoot<RaTypes> = OwnedRoot>(::rowan::SyntaxNode<RaTypes, R>);
 pub type SyntaxNodeRef<'a> = SyntaxNode<RefRoot<'a>>;
 
 impl<R1, R2> PartialEq<SyntaxNode<R1>> for SyntaxNode<R2>
@@ -69,16 +67,16 @@ impl<'a> SyntaxNodeRef<'a> {
     pub fn leaf_text(self) -> Option<&'a SmolStr> {
         self.0.leaf_text()
     }
-    pub fn ancestors(self) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
+    pub fn ancestors(self) -> impl Iterator<Item = SyntaxNodeRef<'a>> {
         crate::algo::generate(Some(self), |&node| node.parent())
     }
-    pub fn descendants(self) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
+    pub fn descendants(self) -> impl Iterator<Item = SyntaxNodeRef<'a>> {
         crate::algo::walk::walk(self).filter_map(|event| match event {
             crate::algo::walk::WalkEvent::Enter(node) => Some(node),
             crate::algo::walk::WalkEvent::Exit(_) => None,
         })
     }
-    pub fn siblings(self, direction: Direction) -> impl Iterator<Item=SyntaxNodeRef<'a>> {
+    pub fn siblings(self, direction: Direction) -> impl Iterator<Item = SyntaxNodeRef<'a>> {
         crate::algo::generate(Some(self), move |&node| match direction {
             Direction::Next => node.next_sibling(),
             Direction::Prev => node.prev_sibling(),
@@ -142,9 +140,7 @@ impl<R: TreeRoot<RaTypes>> fmt::Debug for SyntaxNode<R> {
 }
 
 #[derive(Debug)]
-pub struct SyntaxNodeChildren<R: TreeRoot<RaTypes>>(
-    ::rowan::SyntaxNodeChildren<RaTypes, R>
-);
+pub struct SyntaxNodeChildren<R: TreeRoot<RaTypes>>(::rowan::SyntaxNodeChildren<RaTypes, R>);
 
 impl<R: TreeRoot<RaTypes>> Iterator for SyntaxNodeChildren<R> {
     type Item = SyntaxNode<R>;
@@ -154,7 +150,6 @@ impl<R: TreeRoot<RaTypes>> Iterator for SyntaxNodeChildren<R> {
     }
 }
 
-
 fn has_short_text(kind: SyntaxKind) -> bool {
     use crate::SyntaxKind::*;
     match kind {
diff --git a/crates/ra_syntax/src/yellow/syntax_text.rs b/crates/ra_syntax/src/yellow/syntax_text.rs
index ae33b993d..5395ca90b 100644
--- a/crates/ra_syntax/src/yellow/syntax_text.rs
+++ b/crates/ra_syntax/src/yellow/syntax_text.rs
@@ -1,10 +1,8 @@
-use std::{
-    fmt, ops,
-};
+use std::{fmt, ops};
 
 use crate::{
+    text_utils::{contains_offset_nonstrict, intersect},
     SyntaxNodeRef, TextRange, TextUnit,
-    text_utils::{intersect, contains_offset_nonstrict},
 };
 
 #[derive(Clone)]
@@ -17,19 +15,17 @@ impl<'a> SyntaxText<'a> {
     pub(crate) fn new(node: SyntaxNodeRef<'a>) -> SyntaxText<'a> {
         SyntaxText {
             node,
-            range: node.range()
+            range: node.range(),
         }
     }
-    pub fn chunks(&self) -> impl Iterator<Item=&'a str> {
+    pub fn chunks(&self) -> impl Iterator<Item = &'a str> {
         let range = self.range;
-        self.node
-            .descendants()
-            .filter_map(move |node| {
-                let text = node.leaf_text()?;
-                let range = intersect(range, node.range())?;
-                let range = range - node.range().start();
-                Some(&text[range])
-            })
+        self.node.descendants().filter_map(move |node| {
+            let text = node.leaf_text()?;
+            let range = intersect(range, node.range())?;
+            let range = range - node.range().start();
+            Some(&text[range])
+        })
     }
     pub fn push_to(&self, buf: &mut String) {
         self.chunks().for_each(|it| buf.push_str(it));
@@ -55,11 +51,13 @@ impl<'a> SyntaxText<'a> {
         self.range.len()
     }
     pub fn slice(&self, range: impl SyntaxTextSlice) -> SyntaxText<'a> {
-        let range = range.restrict(self.range)
-            .unwrap_or_else(|| {
-                panic!("invalid slice, range: {:?}, slice: {:?}", self.range, range)
-            });
-        SyntaxText { node: self.node, range }
+        let range = range.restrict(self.range).unwrap_or_else(|| {
+            panic!("invalid slice, range: {:?}, slice: {:?}", self.range, range)
+        });
+        SyntaxText {
+            node: self.node,
+            range,
+        }
     }
     pub fn char_at(&self, offset: TextUnit) -> Option<char> {
         let mut start: TextUnit = 0.into();