Fixed some remaining whitespace issues.

(Not sure if it is correct although).

src/librustc_typeck/check/demand.rs

@@ -132,11 +132,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 let expr_text = print::to_string(print::NO_ANN, |s| s.print_expr(expr));
                 let suggestions = compatible_variants.iter()
                     .map(|v| format!("{}({})", v, expr_text)).collect::<Vec<_>>();
-                err.span_suggestions_with_applicability(expr.span,
-                                     "try using a variant of the expected type",
-                                     suggestions,
-                                     Applicability::MaybeIncorrect,
-                                     );
+                err.span_suggestions_with_applicability(
+                                                 expr.span,
+                                                 "try using a variant of the expected type",
+                                                 suggestions,
+                                                 Applicability::MaybeIncorrect,
+                );
             }
         }
 

src/librustc_typeck/check/method/suggest.rs

@@ -251,15 +251,16 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                 let snippet = tcx.sess.source_map().span_to_snippet(lit.span)
                                     .unwrap_or("<numeric literal>".to_string());
 
-                                err.span_suggestion_with_applicability(lit.span,
+                                err.span_suggestion_with_applicability(
+                                                    lit.span,
                                                     &format!("you must specify a concrete type for \
                                                               this numeric value, like `{}`",
                                                              concrete_type),
                                                     format!("{}_{}",
                                                             snippet,
                                                             concrete_type),
                                                     Applicability::MaybeIncorrect,
-                                                    );
+                                );
                             }
                             hir::ExprKind::Path(ref qpath) => {  // local binding
                                 if let &hir::QPath::Resolved(_, ref path) = &qpath {
@@ -524,7 +525,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                                     &msg,
                                                     path_strings,
                                                     Applicability::MaybeIncorrect,
-                                                    );
+            );
         } else {
             let limit = if candidates.len() == 5 { 5 } else { 4 };
             for (i, trait_did) in candidates.iter().take(limit).enumerate() {

src/librustc_typeck/check/op.rs

@@ -449,7 +449,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                                            msg,
                                                            format!("{}.to_owned()", lstring),
                                                            Applicability::MachineApplicable,
-                                                           ),
+                        ),
                         _ => err.help(msg),
                     };
                 }

src/libsyntax/config.rs

@@ -129,7 +129,7 @@ impl<'a> StripUnconfigured<'a> {
                                                            "expected syntax is",
                                                            suggestion.into(),
                                                            Applicability::MaybeIncorrect,
-                                                           );
+                    );
                 }
                 err.emit();
                 true