Cargo Format

Run `cargo fmt` and ignore generated files

crates/ra_syntax/src/algo/mod.rs

@@ -1,16 +1,18 @@
-pub mod walk;
 pub mod visit;
+pub mod walk;
 
 use crate::{
-    SyntaxNodeRef, TextUnit, TextRange,
     text_utils::{contains_offset_nonstrict, is_subrange},
+    SyntaxNodeRef, TextRange, TextUnit,
 };
 
 pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffset {
     let range = node.range();
     assert!(
         contains_offset_nonstrict(range, offset),
-        "Bad offset: range {:?} offset {:?}", range, offset
+        "Bad offset: range {:?} offset {:?}",
+        range,
+        offset
     );
     if range.is_empty() {
         return LeafAtOffset::None;
@@ -20,20 +22,23 @@ pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffse
         return LeafAtOffset::Single(node);
     }
 
-    let mut children = node.children()
-        .filter(|child| {
-            let child_range = child.range();
-            !child_range.is_empty() && contains_offset_nonstrict(child_range, offset)
-        });
+    let mut children = node.children().filter(|child| {
+        let child_range = child.range();
+        !child_range.is_empty() && contains_offset_nonstrict(child_range, offset)
+    });
 
     let left = children.next().unwrap();
     let right = children.next();
     assert!(children.next().is_none());
     return if let Some(right) = right {
-        match (find_leaf_at_offset(left, offset), find_leaf_at_offset(right, offset)) {
-            (LeafAtOffset::Single(left), LeafAtOffset::Single(right)) =>
-                LeafAtOffset::Between(left, right),
-            _ => unreachable!()
+        match (
+            find_leaf_at_offset(left, offset),
+            find_leaf_at_offset(right, offset),
+        ) {
+            (LeafAtOffset::Single(left), LeafAtOffset::Single(right)) => {
+                LeafAtOffset::Between(left, right)
+            }
+            _ => unreachable!(),
         }
     } else {
         find_leaf_at_offset(left, offset)
@@ -44,7 +49,7 @@ pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffse
 pub enum LeafAtOffset<'a> {
     None,
     Single(SyntaxNodeRef<'a>),
-    Between(SyntaxNodeRef<'a>, SyntaxNodeRef<'a>)
+    Between(SyntaxNodeRef<'a>, SyntaxNodeRef<'a>),
 }
 
 impl<'a> LeafAtOffset<'a> {
@@ -52,7 +57,7 @@ impl<'a> LeafAtOffset<'a> {
         match self {
             LeafAtOffset::None => None,
             LeafAtOffset::Single(node) => Some(node),
-            LeafAtOffset::Between(_, right) => Some(right)
+            LeafAtOffset::Between(_, right) => Some(right),
         }
     }
 
@@ -60,7 +65,7 @@ impl<'a> LeafAtOffset<'a> {
         match self {
             LeafAtOffset::None => None,
             LeafAtOffset::Single(node) => Some(node),
-            LeafAtOffset::Between(left, _) => Some(left)
+            LeafAtOffset::Between(left, _) => Some(left),
         }
     }
 }
@@ -71,8 +76,14 @@ impl<'f> Iterator for LeafAtOffset<'f> {
     fn next(&mut self) -> Option<SyntaxNodeRef<'f>> {
         match *self {
             LeafAtOffset::None => None,
-            LeafAtOffset::Single(node) => { *self = LeafAtOffset::None; Some(node) }
-            LeafAtOffset::Between(left, right) => { *self = LeafAtOffset::Single(right); Some(left) }
+            LeafAtOffset::Single(node) => {
+                *self = LeafAtOffset::None;
+                Some(node)
+            }
+            LeafAtOffset::Between(left, right) => {
+                *self = LeafAtOffset::Single(right);
+                Some(left)
+            }
         }
     }
 }
@@ -81,14 +92,15 @@ pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRe
     assert!(
         is_subrange(root.range(), range),
         "node range: {:?}, target range: {:?}",
-        root.range(), range,
+        root.range(),
+        range,
     );
     let (left, right) = match (
         find_leaf_at_offset(root, range.start()).right_biased(),
-        find_leaf_at_offset(root, range.end()).left_biased()
+        find_leaf_at_offset(root, range.end()).left_biased(),
     ) {
         (Some(l), Some(r)) => (l, r),
-        _ => return root
+        _ => return root,
     };
 
     common_ancestor(left, right)
@@ -103,7 +115,7 @@ fn common_ancestor<'a>(n1: SyntaxNodeRef<'a>, n2: SyntaxNodeRef<'a>) -> SyntaxNo
     panic!("Can't find common ancestor of {:?} and {:?}", n1, n2)
 }
 
-pub fn generate<T>(seed: Option<T>, step: impl Fn(&T) -> Option<T>) -> impl Iterator<Item=T> {
+pub 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);