Cargo Format

Run `cargo fmt` and ignore generated files

1 files changed, 25 insertions, 22 deletions

diff --git a/crates/ra_editor/src/scope/mod_scope.rs b/crates/ra_editor/src/scope/mod_scope.rs
index d2a3e7c58..8d7e408f8 100644
--- a/crates/ra_editor/src/scope/mod_scope.rs
+++ b/crates/ra_editor/src/scope/mod_scope.rs
@@ -1,6 +1,6 @@
 use ra_syntax::{
-    AstNode, SyntaxNode, SyntaxNodeRef, SmolStr,
     ast::{self, AstChildren},
+    AstNode, SmolStr, SyntaxNode, SyntaxNodeRef,
 };
 
 pub struct ModuleScope {
@@ -13,7 +13,8 @@ pub struct Entry {
 }
 
 enum EntryKind {
-    Item, Import,
+    Item,
+    Import,
 }
 
 impl ModuleScope {
@@ -34,9 +35,8 @@ impl ModuleScope {
                         collect_imports(tree, &mut entries);
                     }
                     continue;
-                },
-                ast::ModuleItem::ExternCrateItem(_) |
-                ast::ModuleItem::ImplItem(_) => continue,
+                }
+                ast::ModuleItem::ExternCrateItem(_) | ast::ModuleItem::ImplItem(_) => continue,
             };
             entries.extend(entry)
         }
@@ -52,20 +52,22 @@ impl ModuleScope {
 impl Entry {
     fn new<'a>(item: impl ast::NameOwner<'a>) -> Option<Entry> {
         let name = item.name()?;
-        Some(Entry { node: name.syntax().owned(), kind: EntryKind::Item })
+        Some(Entry {
+            node: name.syntax().owned(),
+            kind: EntryKind::Item,
+        })
     }
     fn new_import(path: ast::Path) -> Option<Entry> {
         let name_ref = path.segment()?.name_ref()?;
-        Some(Entry { node: name_ref.syntax().owned(), kind: EntryKind::Import })
+        Some(Entry {
+            node: name_ref.syntax().owned(),
+            kind: EntryKind::Import,
+        })
     }
     pub fn name(&self) -> SmolStr {
         match self.kind {
-            EntryKind::Item =>
-                ast::Name::cast(self.node.borrowed()).unwrap()
-                    .text(),
-            EntryKind::Import =>
-                ast::NameRef::cast(self.node.borrowed()).unwrap()
-                    .text(),
+            EntryKind::Item => ast::Name::cast(self.node.borrowed()).unwrap().text(),
+            EntryKind::Import => ast::NameRef::cast(self.node.borrowed()).unwrap().text(),
         }
     }
     pub fn syntax(&self) -> SyntaxNodeRef {
@@ -75,32 +77,31 @@ impl Entry {
 
 fn collect_imports(tree: ast::UseTree, acc: &mut Vec<Entry>) {
     if let Some(use_tree_list) = tree.use_tree_list() {
-        return use_tree_list.use_trees().for_each(|it| collect_imports(it, acc));
+        return use_tree_list
+            .use_trees()
+            .for_each(|it| collect_imports(it, acc));
     }
     if let Some(path) = tree.path() {
         acc.extend(Entry::new_import(path));
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ra_syntax::{File, ast::ModuleItemOwner};
+    use ra_syntax::{ast::ModuleItemOwner, File};
 
     fn do_check(code: &str, expected: &[&str]) {
         let file = File::parse(&code);
         let scope = ModuleScope::new(file.ast().items());
-        let actual = scope.entries
-            .iter()
-            .map(|it| it.name())
-            .collect::<Vec<_>>();
+        let actual = scope.entries.iter().map(|it| it.name()).collect::<Vec<_>>();
         assert_eq!(expected, actual.as_slice());
     }
 
     #[test]
     fn test_module_scope() {
-        do_check("
+        do_check(
+            "
             struct Foo;
             enum Bar {}
             mod baz {}
@@ -110,6 +111,8 @@ mod tests {
                 t,
             };
             type T = ();
-        ", &["Foo", "Bar", "baz", "quux", "z", "t", "T"])
+        ",
+            &["Foo", "Bar", "baz", "quux", "z", "t", "T"],
+        )
     }
 }