1 files changed, 21 insertions, 74 deletions

diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 681aa9a67..b7382d9c3 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -83,40 +83,25 @@ pub struct PerNs<T> {
 
 impl<T> Default for PerNs<T> {
     fn default() -> Self {
-        PerNs {
-            types: None,
-            values: None,
-        }
+        PerNs { types: None, values: None }
     }
 }
 
 impl<T> PerNs<T> {
     pub fn none() -> PerNs<T> {
-        PerNs {
-            types: None,
-            values: None,
-        }
+        PerNs { types: None, values: None }
     }
 
     pub fn values(t: T) -> PerNs<T> {
-        PerNs {
-            types: None,
-            values: Some(t),
-        }
+        PerNs { types: None, values: Some(t) }
     }
 
     pub fn types(t: T) -> PerNs<T> {
-        PerNs {
-            types: Some(t),
-            values: None,
-        }
+        PerNs { types: Some(t), values: None }
     }
 
     pub fn both(types: T, values: T) -> PerNs<T> {
-        PerNs {
-            types: Some(types),
-            values: Some(values),
-        }
+        PerNs { types: Some(types), values: Some(values) }
     }
 
     pub fn is_none(&self) -> bool {
@@ -147,31 +132,19 @@ impl<T> PerNs<T> {
     }
 
     pub fn as_ref(&self) -> PerNs<&T> {
-        PerNs {
-            types: self.types.as_ref(),
-            values: self.values.as_ref(),
-        }
+        PerNs { types: self.types.as_ref(), values: self.values.as_ref() }
     }
 
     pub fn combine(self, other: PerNs<T>) -> PerNs<T> {
-        PerNs {
-            types: self.types.or(other.types),
-            values: self.values.or(other.values),
-        }
+        PerNs { types: self.types.or(other.types), values: self.values.or(other.values) }
     }
 
     pub fn and_then<U>(self, f: impl Fn(T) -> Option<U>) -> PerNs<U> {
-        PerNs {
-            types: self.types.and_then(&f),
-            values: self.values.and_then(&f),
-        }
+        PerNs { types: self.types.and_then(&f), values: self.values.and_then(&f) }
     }
 
     pub fn map<U>(self, f: impl Fn(T) -> U) -> PerNs<U> {
-        PerNs {
-            types: self.types.map(&f),
-            values: self.values.map(&f),
-        }
+        PerNs { types: self.types.map(&f), values: self.values.map(&f) }
     }
 }
 
@@ -233,9 +206,7 @@ where
         for dep in self.krate.dependencies(self.db) {
             log::debug!("crate dep {:?} -> {:?}", dep.name, dep.krate);
             if let Some(module) = dep.krate.root_module(self.db) {
-                self.result
-                    .extern_prelude
-                    .insert(dep.name.clone(), module.into());
+                self.result.extern_prelude.insert(dep.name.clone(), module.into());
             }
         }
     }
@@ -245,17 +216,11 @@ where
         for (import_id, import_data) in input.imports.iter() {
             if let Some(last_segment) = import_data.path.segments.iter().last() {
                 if !import_data.is_glob {
-                    let name = import_data
-                        .alias
-                        .clone()
-                        .unwrap_or_else(|| last_segment.name.clone());
-                    module_items.items.insert(
-                        name,
-                        Resolution {
-                            def: PerNs::none(),
-                            import: Some(import_id),
-                        },
-                    );
+                    let name =
+                        import_data.alias.clone().unwrap_or_else(|| last_segment.name.clone());
+                    module_items
+                        .items
+                        .insert(name, Resolution { def: PerNs::none(), import: Some(import_id) });
                 }
             }
         }
@@ -267,10 +232,7 @@ where
 
         // Populate modules
         for (name, module_id) in module_id.children(&self.module_tree) {
-            let module = Module {
-                module_id,
-                krate: self.krate,
-            };
+            let module = Module { module_id, krate: self.krate };
             self.add_module_item(&mut module_items, name, PerNs::types(module.into()));
         }
 
@@ -305,20 +267,13 @@ where
         if import.is_glob {
             return ReachedFixedPoint::Yes;
         };
-        let original_module = Module {
-            krate: self.krate,
-            module_id,
-        };
+        let original_module = Module { krate: self.krate, module_id };
         let (def, reached_fixedpoint) =
-            self.result
-                .resolve_path_fp(self.db, original_module, &import.path);
+            self.result.resolve_path_fp(self.db, original_module, &import.path);
 
         if reached_fixedpoint == ReachedFixedPoint::Yes {
             let last_segment = import.path.segments.last().unwrap();
-            let name = import
-                .alias
-                .clone()
-                .unwrap_or_else(|| last_segment.name.clone());
+            let name = import.alias.clone().unwrap_or_else(|| last_segment.name.clone());
             log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
 
             // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
@@ -330,10 +285,7 @@ where
                 }
             }
             self.update(module_id, |items| {
-                let res = Resolution {
-                    def,
-                    import: Some(import_id),
-                };
+                let res = Resolution { def, import: Some(import_id) };
                 items.items.insert(name, res);
             });
         }
@@ -358,12 +310,7 @@ impl ItemMap {
         let module_tree = db.module_tree(krate);
         let input = module_tree
             .modules()
-            .map(|module_id| {
-                (
-                    module_id,
-                    db.lower_module_module(Module { krate, module_id }),
-                )
-            })
+            .map(|module_id| (module_id, db.lower_module_module(Module { krate, module_id })))
             .collect::<FxHashMap<_, _>>();
 
         let resolver = Resolver::new(db, &input, krate);