Fix trailing whitespace and duplicate error code.

New error code is E0623
Also cleanup/fix ui test

Author: Emilgardis

src/librustc/diagnostics.rs

@@ -2027,5 +2027,5 @@ register_diagnostics! {
     E0495, // cannot infer an appropriate lifetime due to conflicting requirements
     E0566, // conflicting representation hints
     E0587, // conflicting packed and align representation hints
-    E0622, // type mismatch in closure arguments
+    E0623, // type mismatch in closure arguments
 }

src/librustc/traits/error_reporting.rs

@@ -728,7 +728,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                     let mut count_mismatch = None;
                     if let ty::TyTuple(expected_tys, _) = expected_found.expected.sty {
                         if let ty::TyTuple(found_tys, _) = expected_found.found.sty {
-                            if expected_tys.len() != found_tys.len() { 
+                            if expected_tys.len() != found_tys.len() {
                                 // Expected `|| { }`, found `|x, y| { }`
                                 // Expected `fn(x) -> ()`, found `|| { }`
                                 count_mismatch = Some(self.report_arg_count_mismatch(span,
@@ -745,7 +745,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                        self.report_closure_arg_mismatch(span,
                                                          found_span,
                                                          expected_trait_ref,
-                                                         actual_trait_ref) 
+                                                         actual_trait_ref)
                     }
                 } else {
                     self.report_type_argument_mismatch(span,
@@ -828,15 +828,14 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                            found: ty::PolyTraitRef<'tcx>)
         -> DiagnosticBuilder<'tcx>
     {
-        let mut err = struct_span_err!(self.tcx.sess, span, E0622,
+        let mut err = struct_span_err!(self.tcx.sess, span, E0623,
             "type mismatch in closure arguments");
         if let Some(sp) = found_span {
             err.span_label(span, format!("expected closure that takes a `{}`", found));
             err.span_label(sp, format!("takes a `{}`", expected_ref));
         } else {
             panic!();
         }
-        
         err
     }
 }

src/test/ui/mismatched_types/closure-arg-type-mismatch.rs

@@ -8,14 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::ops::{FnOnce, Fn};
-
-pub fn main() {
+fn main() {
         let a = [(1u32,2u32)];
         let b = a.iter().map(|x: (u32, u32)| 45);
         let d1 = a.iter().map(|x: &(u16,u16)| 45);
         let d2 = a.iter().map(|x: (u16,u16)| 45);
         foo(|y: isize| ());
 }
 
-fn foo<F>(m: F) where F: Fn(usize) {}
+fn foo<F>(m: F) where F: ::std::ops::Fn(usize) {}

src/test/ui/mismatched_types/closure-arg-type-mismatch.stderr

@@ -1,31 +1,31 @@
-error[E0622]: type mismatch in closure arguments
-  --> $DIR/closure-arg-type-mismatch.rs:15:26
+error[E0623]: type mismatch in closure arguments
+  --> $DIR/closure-arg-type-mismatch.rs:13:26
    |
-15 |         let b = a.iter().map(|x: (u32, u32)| 45);
+13 |         let b = a.iter().map(|x: (u32, u32)| 45);
    |                          ^^^ ------------------ takes a `std::ops::FnMut<((u32, u32),)>`
    |                          |
    |                          expected closure that takes a `std::ops::FnMut<(&(u32, u32),)>`
 
-error[E0622]: type mismatch in closure arguments
-  --> $DIR/closure-arg-type-mismatch.rs:16:27
+error[E0623]: type mismatch in closure arguments
+  --> $DIR/closure-arg-type-mismatch.rs:14:27
    |
-16 |         let d1 = a.iter().map(|x: &(u16,u16)| 45);
+14 |         let d1 = a.iter().map(|x: &(u16,u16)| 45);
    |                           ^^^ ------------------ takes a `for<'r> std::ops::FnMut<(&'r (u16, u16),)>`
    |                           |
    |                           expected closure that takes a `std::ops::FnMut<(&(u32, u32),)>`
 
-error[E0622]: type mismatch in closure arguments
-  --> $DIR/closure-arg-type-mismatch.rs:17:27
+error[E0623]: type mismatch in closure arguments
+  --> $DIR/closure-arg-type-mismatch.rs:15:27
    |
-17 |         let d2 = a.iter().map(|x: (u16,u16)| 45);
+15 |         let d2 = a.iter().map(|x: (u16,u16)| 45);
    |                           ^^^ ----------------- takes a `std::ops::FnMut<((u16, u16),)>`
    |                           |
    |                           expected closure that takes a `std::ops::FnMut<(&(u32, u32),)>`
 
-error[E0622]: type mismatch in closure arguments
-  --> $DIR/closure-arg-type-mismatch.rs:18:9
+error[E0623]: type mismatch in closure arguments
+  --> $DIR/closure-arg-type-mismatch.rs:16:9
    |
-18 |         foo(|y: isize| ());
+16 |         foo(|y: isize| ());
    |         ^^^ ------------- takes a `std::ops::Fn<(isize,)>`
    |         |
    |         expected closure that takes a `std::ops::Fn<(usize,)>`