Fix wrong report on closure args mismatch when a

ref is expected but not found

Fixes rust-lang#42143

Adds E0604 for closure argument type mismatch

Author: Emilgardis

src/librustc/diagnostics.rs

@@ -1943,4 +1943,5 @@ register_diagnostics! {
     E0495, // cannot infer an appropriate lifetime due to conflicting requirements
     E0566, // conflicting representation hints
     E0587, // conflicting packed and align representation hints
+    E0604, // closure arguments mismatch
 }

src/librustc/traits/error_reporting.rs

@@ -684,44 +684,37 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                                                    expected_found.found,
                                                    expected_trait_ty.is_closure())
                 } else if let &TypeError::Sorts(ref expected_found) = e {
-                    let expected_len = if let ty::TyTuple(tys, _) = expected_found.expected.sty {
-                        tys.len()
-                    } else if let ty::TyRef(_,ty::TypeAndMut{ty,..}) = expected_found.expected.sty {
-                        if let ty::TyTuple(tys,_) = ty.sty {
-                            tys.len()
-                        } else {
-                            1
-                        }
-                    } else {
-                        1
-                    };
-                    let found_len = if let ty::TyTuple(tys, _) = expected_found.found.sty {
-                        tys.len()
-                    } else if let ty::TyRef(_,ty::TypeAndMut{ty,..}) = expected_found.found.sty {
-                        if let ty::TyTuple(tys,_) = ty.sty {
-                            tys.len()
-                        } else {
-                            1
+                    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() { 
+                                // Expected `|| { }`, found `|x, y| { }`
+                                // Expected `fn(x) -> ()`, found `|| { }`
+                                count_mismatch = Some(self.report_arg_count_mismatch(span,
+                                                               found_span,
+                                                               expected_tys.len(),
+                                                               found_tys.len(),
+                                                               expected_trait_ty.is_closure()));
+                            }
                         }
+                    }
+
+                    //} else if false {
+                    //    self.report_type_argument_mismatch(span,
+                    //                                        found_span,
+                    //                                        expected_trait_ty,
+                    //                                        expected_trait_ref,
+                    //                                        actual_trait_ref,
+                    //                                        e)
+                    if count_mismatch.is_none() {
+                        self.report_closure_arg_mismatch(span,
+                                                         found_span,
+                                                         expected_trait_ty,
+                                                         expected_trait_ref,
+                                                         actual_trait_ref,
+                                                         e)
                     } else {
-                        1
-                    };
-
-                    if expected_len != found_len {
-                        // Expected `|| { }`, found `|x, y| { }`
-                        // Expected `fn(x) -> ()`, found `|| { }`
-                        self.report_arg_count_mismatch(span,
-                                                       found_span,
-                                                       expected_len,
-                                                       found_len,
-                                                       expected_trait_ty.is_closure())
-                    } else {
-                        self.report_type_argument_mismatch(span,
-                                                            found_span,
-                                                            expected_trait_ty,
-                                                            expected_trait_ref,
-                                                            actual_trait_ref,
-                                                            e)
+                       count_mismatch.unwrap() 
                     }
                 } else {
                     self.report_type_argument_mismatch(span,
@@ -767,7 +760,23 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
 
         err
     }
-
+    fn report_closure_arg_mismatch(&self,
+                           span: Span,
+                           found_span: Option<Span>,
+                           expected: Ty<'tcx>,
+                           expected_ref: ty::PolyTraitRef<'tcx>,
+                           found: ty::PolyTraitRef<'tcx>,
+                           _type_error: &TypeError<'tcx>) -> DiagnosticBuilder<'tcx>
+    {
+        let mut err = struct_span_err!(self.tcx.sess, span, E0604,
+            "type mismatch in closure arguments");
+        if let Some(sp) = found_span {
+            err.span_label(span, format!("expected closure that takes a `{}`", found.self_ty().subst().type_at(0)));
+            err.span_label(sp, format!("takes a `{}`", expected_ref.0));
+        }
+        
+        err
+    }
     fn report_arg_count_mismatch(&self,
                                  span: Span,
                                  found_span: Option<Span>,