1 files changed, 58 insertions, 50 deletions

diff --git a/crates/ra_analysis/src/descriptors.rs b/crates/ra_analysis/src/descriptors.rs
index 8d9f38ca5..6f26f9935 100644
--- a/crates/ra_analysis/src/descriptors.rs
+++ b/crates/ra_analysis/src/descriptors.rs
@@ -1,41 +1,34 @@
-use std::{
-    collections::BTreeMap,
-};
-use relative_path::RelativePathBuf;
+use crate::{imp::FileResolverImp, FileId};
 use ra_syntax::{
+    ast::{self, AstNode, NameOwner},
+    text_utils::is_subrange,
     SmolStr,
-    ast::{self, NameOwner, AstNode},
-    text_utils::is_subrange
-};
-use crate::{
-    FileId,
-    imp::FileResolverImp,
 };
+use relative_path::RelativePathBuf;
+
+use std::collections::BTreeMap;
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct ModuleDescriptor {
-    pub submodules: Vec<Submodule>
+    pub submodules: Vec<Submodule>,
 }
 
 impl ModuleDescriptor {
     pub fn new(root: ast::Root) -> ModuleDescriptor {
-        let submodules = modules(root)
-            .map(|(name, _)| Submodule { name })
-            .collect();
+        let submodules = modules(root).map(|(name, _)| Submodule { name }).collect();
 
-        ModuleDescriptor { submodules } }
+        ModuleDescriptor { submodules }
+    }
 }
 
-fn modules<'a>(root: ast::Root<'a>) -> impl Iterator<Item=(SmolStr, ast::Module<'a>)> {
-    root
-        .modules()
-        .filter_map(|module| {
-            let name = module.name()?.text();
-            if !module.has_semi() {
-                return None;
-            }
-            Some((name, module))
-        })
+fn modules<'a>(root: ast::Root<'a>) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
+    root.modules().filter_map(|module| {
+        let name = module.name()?.text();
+        if !module.has_semi() {
+            return None;
+        }
+        Some((name, module))
+    })
 }
 
 #[derive(Clone, Hash, PartialEq, Eq, Debug)]
@@ -56,7 +49,7 @@ struct Node(usize);
 struct NodeData {
     file_id: FileId,
     links: Vec<Link>,
-    parents: Vec<Link>
+    parents: Vec<Link>,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
@@ -69,7 +62,6 @@ struct LinkData {
     problem: Option<Problem>,
 }
 
-
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum Problem {
     UnresolvedModule {
@@ -78,16 +70,18 @@ pub enum Problem {
     NotDirOwner {
         move_to: RelativePathBuf,
         candidate: RelativePathBuf,
-    }
+    },
 }
 
 impl ModuleTreeDescriptor {
     pub(crate) fn new<'a>(
-        files: impl Iterator<Item=(FileId, &'a ModuleDescriptor)> + Clone,
+        files: impl Iterator<Item = (FileId, &'a ModuleDescriptor)> + Clone,
         file_resolver: &FileResolverImp,
     ) -> ModuleTreeDescriptor {
         let mut file_id2node = BTreeMap::new();
-        let mut nodes: Vec<NodeData> = files.clone().enumerate()
+        let mut nodes: Vec<NodeData> = files
+            .clone()
+            .enumerate()
             .map(|(idx, (file_id, _))| {
                 file_id2node.insert(file_id, Node(idx));
                 NodeData {
@@ -120,20 +114,19 @@ impl ModuleTreeDescriptor {
                     points_to,
                     problem,
                 })
-
             }
         }
 
         ModuleTreeDescriptor {
-            nodes, links, file_id2node
+            nodes,
+            links,
+            file_id2node,
         }
     }
 
     pub(crate) fn parent_modules(&self, file_id: FileId) -> Vec<Link> {
         let node = self.file_id2node[&file_id];
-        self.node(node)
-            .parents
-            .clone()
+        self.node(node).parents.clone()
     }
     pub(crate) fn child_module_by_name(&self, file_id: FileId, name: &str) -> Vec<FileId> {
         let node = self.file_id2node[&file_id];
@@ -141,10 +134,18 @@ impl ModuleTreeDescriptor {
             .links
             .iter()
             .filter(|it| it.name(self) == name)
-            .flat_map(|link| link.points_to(self).iter().map(|&node| self.node(node).file_id))
+            .flat_map(|link| {
+                link.points_to(self)
+                    .iter()
+                    .map(|&node| self.node(node).file_id)
+            })
             .collect()
     }
-    pub(crate) fn problems<'a, 'b>(&'b self, file_id: FileId, root: ast::Root<'a>) -> Vec<(ast::Name<'a>, &'b Problem)> {
+    pub(crate) fn problems<'a, 'b>(
+        &'b self,
+        file_id: FileId,
+        root: ast::Root<'a>,
+    ) -> Vec<(ast::Name<'a>, &'b Problem)> {
         let node = self.file_id2node[&file_id];
         self.node(node)
             .links
@@ -176,7 +177,11 @@ impl Link {
     fn points_to(self, tree: &ModuleTreeDescriptor) -> &[Node] {
         &tree.link(self).points_to
     }
-    pub(crate) fn bind_source<'a>(self, tree: &ModuleTreeDescriptor, root: ast::Root<'a>) -> ast::Module<'a> {
+    pub(crate) fn bind_source<'a>(
+        self,
+        tree: &ModuleTreeDescriptor,
+        root: ast::Root<'a>,
+    ) -> ast::Module<'a> {
         modules(root)
             .filter(|(name, _)| name == &tree.link(self).name)
             .next()
@@ -185,22 +190,21 @@ impl Link {
     }
 }
 
-
 fn resolve_submodule(
     file_id: FileId,
     name: &SmolStr,
-    file_resolver: &FileResolverImp
+    file_resolver: &FileResolverImp,
 ) -> (Vec<FileId>, Option<Problem>) {
     let mod_name = file_resolver.file_stem(file_id);
-    let is_dir_owner =
-        mod_name == "mod" || mod_name == "lib" || mod_name == "main";
+    let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
 
     let file_mod = RelativePathBuf::from(format!("../{}.rs", name));
     let dir_mod = RelativePathBuf::from(format!("../{}/mod.rs", name));
     let points_to: Vec<FileId>;
     let problem: Option<Problem>;
     if is_dir_owner {
-        points_to = [&file_mod, &dir_mod].iter()
+        points_to = [&file_mod, &dir_mod]
+            .iter()
             .filter_map(|path| file_resolver.resolve(file_id, path))
             .collect();
         problem = if points_to.is_empty() {
@@ -223,7 +227,7 @@ fn resolve_submodule(
 #[derive(Debug, Clone)]
 pub struct FnDescriptor {
     pub name: String,
-    pub label : String,
+    pub label: String,
     pub ret_type: Option<String>,
     pub params: Vec<String>,
 }
@@ -233,9 +237,11 @@ impl FnDescriptor {
         let name = node.name()?.text().to_string();
 
         // Strip the body out for the label.
-        let label : String = if let Some(body) = node.body() {
+        let label: String = if let Some(body) = node.body() {
             let body_range = body.syntax().range();
-            let label : String = node.syntax().children()
+            let label: String = node
+                .syntax()
+                .children()
                 .filter(|child| !is_subrange(body_range, child.range()))
                 .map(|node| node.text().to_string())
                 .collect();
@@ -251,7 +257,7 @@ impl FnDescriptor {
             name,
             ret_type,
             params,
-            label
+            label,
         })
     }
 
@@ -264,9 +270,11 @@ impl FnDescriptor {
 
             // Maybe use param.pat here? See if we can just extract the name?
             //res.extend(param_list.params().map(|p| p.syntax().text().to_string()));
-            res.extend(param_list.params()
-                .filter_map(|p| p.pat())
-                .map(|pat| pat.syntax().text().to_string())
+            res.extend(
+                param_list
+                    .params()
+                    .filter_map(|p| p.pat())
+                    .map(|pat| pat.syntax().text().to_string()),
             );
         }
         res