Auto merge of #29387 - little-dude:rustfmt_librustc_resolve, r=nrc

Another rustfmt PR.
I ran rustfmt, then split the changes in multiple commits. First commit are the non-problematic changed. The others are all the little weirdness that caught my attention and could be discussed.

Author: bors

src/librustc_resolve/build_reduced_graph.rs

@@ -31,8 +31,8 @@ use rustc_front::hir;
 use rustc_front::hir::{ViewPathGlob, ViewPathList, ViewPathSimple};
 use rustc_front::visit::{self, Visitor};
 
-struct UnusedImportCheckVisitor<'a, 'b:'a, 'tcx:'b> {
-    resolver: &'a mut Resolver<'b, 'tcx>
+struct UnusedImportCheckVisitor<'a, 'b: 'a, 'tcx: 'b> {
+    resolver: &'a mut Resolver<'b, 'tcx>,
 }
 
 // Deref and DerefMut impls allow treating UnusedImportCheckVisitor as Resolver.
@@ -51,16 +51,16 @@ impl<'a, 'b, 'tcx:'b> DerefMut for UnusedImportCheckVisitor<'a, 'b, 'tcx> {
 }
 
 impl<'a, 'b, 'tcx> UnusedImportCheckVisitor<'a, 'b, 'tcx> {
-    // We have information about whether `use` (import) directives are actually used now.
-    // If an import is not used at all, we signal a lint error. If an import is only used
-    // for a single namespace, we remove the other namespace from the recorded privacy
-    // information. That means in privacy.rs, we will only check imports and namespaces
-    // which are used. In particular, this means that if an import could name either a
-    // public or private item, we will check the correct thing, dependent on how the import
-    // is used.
+    // We have information about whether `use` (import) directives are actually
+    // used now. If an import is not used at all, we signal a lint error. If an
+    // import is only used for a single namespace, we remove the other namespace
+    // from the recorded privacy information. That means in privacy.rs, we will
+    // only check imports and namespaces which are used. In particular, this
+    // means that if an import could name either a public or private item, we
+    // will check the correct thing, dependent on how the import is used.
     fn finalize_import(&mut self, id: ast::NodeId, span: Span) {
         debug!("finalizing import uses for {:?}",
-                self.session.codemap().span_to_snippet(span));
+               self.session.codemap().span_to_snippet(span));
 
         if !self.used_imports.contains(&(id, TypeNS)) &&
            !self.used_imports.contains(&(id, ValueNS)) {
@@ -99,14 +99,14 @@ impl<'a, 'b, 'tcx> UnusedImportCheckVisitor<'a, 'b, 'tcx> {
             // we might have two LastPrivates pointing at the same thing. There is no point
             // checking both, so lets not check the value one.
             (Some(DependsOn(def_v)), Some(DependsOn(def_t))) if def_v == def_t => v_used = Unused,
-            _ => {},
+            _ => {}
         }
 
         path_res.last_private = LastImport {
             value_priv: v_priv,
             value_used: v_used,
             type_priv: t_priv,
-            type_used: t_used
+            type_used: t_used,
         };
     }
 }
@@ -132,7 +132,7 @@ impl<'a, 'b, 'v, 'tcx> Visitor<'v> for UnusedImportCheckVisitor<'a, 'b, 'tcx> {
                                               "unused extern crate".to_string());
                     }
                 }
-            },
+            }
             hir::ItemUse(ref p) => {
                 match p.node {
                     ViewPathSimple(_, _) => {

src/librustc_resolve/check_unused.rs

@@ -10,9 +10,9 @@
 
 #![allow(non_snake_case)]
 
-// Error messages for EXXXX errors.
-// Each message should start and end with a new line, and be wrapped to 80 characters.
-// In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use `:set tw=0` to disable.
+// Error messages for EXXXX errors.  Each message should start and end with a
+// new line, and be wrapped to 80 characters.  In vim you can `:set tw=80` and
+// use `gq` to wrap paragraphs. Use `:set tw=0` to disable.
 register_long_diagnostics! {
 
 E0154: r##"

src/librustc_resolve/diagnostics.rs

@@ -30,8 +30,8 @@ use syntax::ast;
 use std::ops::{Deref, DerefMut};
 use std::rc::Rc;
 
-struct ExportRecorder<'a, 'b:'a, 'tcx:'b> {
-    resolver: &'a mut Resolver<'b, 'tcx>
+struct ExportRecorder<'a, 'b: 'a, 'tcx: 'b> {
+    resolver: &'a mut Resolver<'b, 'tcx>,
 }
 
 // Deref and DerefMut impls allow treating ExportRecorder as Resolver.
@@ -50,28 +50,26 @@ impl<'a, 'b, 'tcx:'b> DerefMut for ExportRecorder<'a, 'b, 'tcx> {
 }
 
 impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> {
-    fn record_exports_for_module_subtree(&mut self,
-                                         module_: Rc<Module>) {
+    fn record_exports_for_module_subtree(&mut self, module_: Rc<Module>) {
         // If this isn't a local krate, then bail out. We don't need to record
         // exports for nonlocal crates.
 
         match module_.def_id.get() {
             Some(def_id) if def_id.is_local() => {
                 // OK. Continue.
-                debug!("(recording exports for module subtree) recording \
-                        exports for local module `{}`",
+                debug!("(recording exports for module subtree) recording exports for local \
+                        module `{}`",
                        module_to_string(&*module_));
             }
             None => {
                 // Record exports for the root module.
-                debug!("(recording exports for module subtree) recording \
-                        exports for root module `{}`",
+                debug!("(recording exports for module subtree) recording exports for root module \
+                        `{}`",
                        module_to_string(&*module_));
             }
             Some(_) => {
                 // Bail out.
-                debug!("(recording exports for module subtree) not recording \
-                        exports for `{}`",
+                debug!("(recording exports for module subtree) not recording exports for `{}`",
                        module_to_string(&*module_));
                 return;
             }
@@ -118,10 +116,11 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> {
         match namebindings.def_for_namespace(ns) {
             Some(d) => {
                 debug!("(computing exports) YES: export '{}' => {:?}",
-                       name, d.def_id());
+                       name,
+                       d.def_id());
                 exports.push(Export {
                     name: name,
-                    def_id: d.def_id()
+                    def_id: d.def_id(),
                 });
             }
             d_opt => {
@@ -130,25 +129,19 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> {
         }
     }
 
-    fn add_exports_for_module(&mut self,
-                              exports: &mut Vec<Export>,
-                              module_: &Module) {
+    fn add_exports_for_module(&mut self, exports: &mut Vec<Export>, module_: &Module) {
         for (name, import_resolution) in module_.import_resolutions.borrow().iter() {
             if !import_resolution.is_public {
-                continue
+                continue;
             }
             let xs = [TypeNS, ValueNS];
             for &ns in &xs {
                 match import_resolution.target_for_namespace(ns) {
                     Some(target) => {
-                        debug!("(computing exports) maybe export '{}'",
-                               name);
-                        self.add_exports_of_namebindings(exports,
-                                                         *name,
-                                                         &*target.bindings,
-                                                         ns)
+                        debug!("(computing exports) maybe export '{}'", name);
+                        self.add_exports_of_namebindings(exports, *name, &*target.bindings, ns)
                     }
-                    _ => ()
+                    _ => (),
                 }
             }
         }