Refactored a few bits:

- Firstly get all the information about generics matching out of the HIR
- Secondly the labelling for the function is more coherent now
- Lastly a few error message improvements

Author: strottos

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -424,7 +424,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 "expected formal_input_tys to be the same size as expected_input_tys"
             );
             let formal_and_expected_inputs = IndexVec::from_iter(
-                formal_input_tys.iter().copied().zip_eq(expected_input_tys.iter().copied()),
+                formal_input_tys
+                    .iter()
+                    .copied()
+                    .zip_eq(expected_input_tys.iter().copied())
+                    .map(|vars| self.resolve_vars_if_possible(vars)),
             );
 
             self.set_tainted_by_errors(self.report_arg_errors(
@@ -639,8 +643,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
 
             let (formal_input_ty, expected_input_ty) = formal_and_expected_inputs[expected_idx];
-            let formal_input_ty = self.resolve_vars_if_possible(formal_input_ty);
-            let expected_input_ty = self.resolve_vars_if_possible(expected_input_ty);
             // If either is an error type, we defy the usual convention and consider them to *not* be
             // coercible. This prevents our error message heuristic from trying to pass errors into
             // every argument.
@@ -713,7 +715,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // Do we have as many extra provided arguments as the tuple's length?
             // If so, we might have just forgotten to wrap some args in a tuple.
             if let Some(ty::Tuple(tys)) =
-                formal_and_expected_inputs.get(mismatch_idx.into()).map(|tys| self.resolve_vars_if_possible(tys.1).kind())
+                formal_and_expected_inputs.get(mismatch_idx.into()).map(|tys| tys.1.kind())
                 // If the tuple is unit, we're not actually wrapping any arguments.
                 && !tys.is_empty()
                 && provided_arg_tys.len() == formal_and_expected_inputs.len() - 1 + tys.len()
@@ -732,7 +734,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         provided_arg_tys.iter().map(|(ty, _)| *ty).skip(mismatch_idx + tys.len()),
                     ),
                 ) {
-                    if !self.can_coerce(provided_ty, self.resolve_vars_if_possible(*expected_ty)) {
+                    if !self.can_coerce(provided_ty, *expected_ty) {
                         satisfied = false;
                         break;
                     }
@@ -751,14 +753,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     if tys.len() == 1 {
                         // A tuple wrap suggestion actually occurs within,
                         // so don't do anything special here.
-                        let (formal_ty, expected_ty) =
-                            formal_and_expected_inputs[mismatch_idx.into()];
-                        let formal_ty = self.resolve_vars_if_possible(formal_ty);
-                        let expected_ty = self.resolve_vars_if_possible(expected_ty);
                         err = self.err_ctxt().report_and_explain_type_error(
                             mk_trace(
                                 *lo,
-                                (formal_ty, expected_ty),
+                                formal_and_expected_inputs[mismatch_idx.into()],
                                 provided_arg_tys[mismatch_idx.into()].0,
                             ),
                             terr,
@@ -842,10 +840,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return true;
             };
             let (provided_ty, provided_span) = provided_arg_tys[*provided_idx];
-            let (formal_ty, expected_ty) = formal_and_expected_inputs[*expected_idx];
-            let formal_ty = self.resolve_vars_if_possible(formal_ty);
-            let expected_ty = self.resolve_vars_if_possible(expected_ty);
-            let trace = mk_trace(provided_span, (formal_ty, expected_ty), provided_ty);
+            let trace =
+                mk_trace(provided_span, formal_and_expected_inputs[*expected_idx], provided_ty);
             if !matches!(trace.cause.as_failure_code(*e), FailureCode::Error0308) {
                 let mut err = self.err_ctxt().report_and_explain_type_error(trace, *e);
                 suggest_confusable(&mut err);
@@ -873,8 +869,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         ] = &errors[..]
         {
             let (formal_ty, expected_ty) = formal_and_expected_inputs[*expected_idx];
-            let formal_ty = self.resolve_vars_if_possible(formal_ty);
-            let expected_ty = self.resolve_vars_if_possible(expected_ty);
             let (provided_ty, provided_arg_span) = provided_arg_tys[*provided_idx];
             let trace = mk_trace(provided_arg_span, (formal_ty, expected_ty), provided_ty);
             let mut err = self.err_ctxt().report_and_explain_type_error(trace, *err);
@@ -896,6 +890,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 &matched_inputs,
                 &provided_arg_tys,
                 &formal_and_expected_inputs,
+                is_method,
             );
 
             if let hir::ExprKind::MethodCall(_, rcvr, _, _) = call_expr.kind
@@ -1003,8 +998,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             match error {
                 Error::Invalid(provided_idx, expected_idx, compatibility) => {
                     let (formal_ty, expected_ty) = formal_and_expected_inputs[expected_idx];
-                    let formal_ty = self.resolve_vars_if_possible(formal_ty);
-                    let expected_ty = self.resolve_vars_if_possible(expected_ty);
                     let (provided_ty, provided_span) = provided_arg_tys[provided_idx];
                     if let Compatibility::Incompatible(error) = compatibility {
                         let trace = mk_trace(provided_span, (formal_ty, expected_ty), provided_ty);
@@ -1109,7 +1102,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     match &missing_idxs[..] {
                         &[expected_idx] => {
                             let (_, input_ty) = formal_and_expected_inputs[expected_idx];
-                            let input_ty = self.resolve_vars_if_possible(input_ty);
                             let span = if let Some((_, arg_span)) =
                                 provided_arg_tys.get(expected_idx.to_provided_idx())
                             {
@@ -1132,10 +1124,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         &[first_idx, second_idx] => {
                             let (_, first_expected_ty) = formal_and_expected_inputs[first_idx];
                             let (_, second_expected_ty) = formal_and_expected_inputs[second_idx];
-                            let first_expected_ty =
-                                self.resolve_vars_if_possible(first_expected_ty);
-                            let second_expected_ty =
-                                self.resolve_vars_if_possible(second_expected_ty);
                             let span = if let (Some((_, first_span)), Some((_, second_span))) = (
                                 provided_arg_tys.get(first_idx.to_provided_idx()),
                                 provided_arg_tys.get(second_idx.to_provided_idx()),
@@ -1162,14 +1150,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         }
                         &[first_idx, second_idx, third_idx] => {
                             let (_, first_expected_ty) = formal_and_expected_inputs[first_idx];
-                            let first_expected_ty =
-                                self.resolve_vars_if_possible(first_expected_ty);
                             let (_, second_expected_ty) = formal_and_expected_inputs[second_idx];
-                            let second_expected_ty =
-                                self.resolve_vars_if_possible(second_expected_ty);
                             let (_, third_expected_ty) = formal_and_expected_inputs[third_idx];
-                            let third_expected_ty =
-                                self.resolve_vars_if_possible(third_expected_ty);
                             let span = if let (Some((_, first_span)), Some((_, third_span))) = (
                                 provided_arg_tys.get(first_idx.to_provided_idx()),
                                 provided_arg_tys.get(third_idx.to_provided_idx()),
@@ -1229,7 +1211,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ) => {
                     let (first_provided_ty, first_span) = provided_arg_tys[first_provided_idx];
                     let (_, first_expected_ty) = formal_and_expected_inputs[first_expected_idx];
-                    let first_expected_ty = self.resolve_vars_if_possible(first_expected_ty);
                     let first_provided_ty_name = if !has_error_or_infer([first_provided_ty]) {
                         format!(", found `{first_provided_ty}`")
                     } else {
@@ -1242,7 +1223,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
                     let (second_provided_ty, second_span) = provided_arg_tys[second_provided_idx];
                     let (_, second_expected_ty) = formal_and_expected_inputs[second_expected_idx];
-                    let second_provided_ty = self.resolve_vars_if_possible(second_provided_ty);
                     let second_provided_ty_name = if !has_error_or_infer([second_provided_ty]) {
                         format!(", found `{second_provided_ty}`")
                     } else {
@@ -1261,7 +1241,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Error::Permutation(args) => {
                     for (dst_arg, dest_input) in args {
                         let (_, expected_ty) = formal_and_expected_inputs[dst_arg];
-                        let expected_ty = self.resolve_vars_if_possible(expected_ty);
                         let (provided_ty, provided_span) = provided_arg_tys[dest_input];
                         let provided_ty_name = if !has_error_or_infer([provided_ty]) {
                             format!(", found `{provided_ty}`")
@@ -1288,6 +1267,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             &matched_inputs,
             &provided_arg_tys,
             &formal_and_expected_inputs,
+            is_method,
         );
 
         // Incorporate the argument changes in the removal suggestion.
@@ -1325,7 +1305,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // To suggest a multipart suggestion when encountering `foo(1, "")` where the def
                 // was `fn foo(())`.
                 let (_, expected_ty) = formal_and_expected_inputs[expected_idx];
-                let expected_ty = self.resolve_vars_if_possible(expected_ty);
                 suggestions.push((*arg_span, ty_to_snippet(expected_ty, expected_idx)));
             }
         }
@@ -1402,7 +1381,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 } else {
                     // Propose a placeholder of the correct type
                     let (_, expected_ty) = formal_and_expected_inputs[expected_idx];
-                    let expected_ty = self.resolve_vars_if_possible(expected_ty);
                     ty_to_snippet(expected_ty, expected_idx)
                 };
                 suggestion += &suggestion_text;
@@ -2475,77 +2453,53 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         matched_inputs: &IndexVec<ExpectedIdx, Option<ProvidedIdx>>,
         provided_arg_tys: &IndexVec<ProvidedIdx, (Ty<'tcx>, Span)>,
         formal_and_expected_inputs: &IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
+        is_method: bool,
     ) {
         let Some(def_id) = callable_def_id else {
             return;
         };
 
-        for (matched_idx, matched_arg) in matched_inputs.iter_enumerated() {
-            let Some(matched_input) = matched_arg else {
+        let params_with_generics = self.get_hir_params_with_generics(def_id, is_method);
+
+        for (idx, (generic_param, _)) in params_with_generics.iter().enumerate() {
+            if matched_inputs[idx.into()].is_none() {
+                continue;
+            }
+
+            let Some((_, matched_arg_span)) = provided_arg_tys.get(idx.into()) else {
                 continue;
             };
 
-            let (_, matched_arg_span) = provided_arg_tys[*matched_input];
-            let (matched_formal_ty, _) = formal_and_expected_inputs[matched_idx];
-            let ty::Infer(ty::TyVar(a)) = matched_formal_ty.kind() else {
+            let Some(generic_param) = generic_param else {
                 continue;
             };
 
-            let mut formal_ty_idxs_matched: Vec<usize> = vec![];
-            let mut expected_ty_matched = None;
-            for (input_idx, (formal_ty, expected_ty)) in formal_and_expected_inputs
-                .iter_enumerated()
-                // Only care about args after the matched one we're checking.
-                //
-                // NB: Incompatible should always come after their matching generics.
-                // e.g. if we have a function fn f(a: T, b: T, c: T) and we call it with
-                // f(1, 2, 3.0) then the first will force T to be an integer, the second
-                // then matches and the third is the incompatible argument.
-                .filter(|(idx, _)| *idx > matched_idx)
-            {
-                if let ty::Infer(ty::TyVar(b)) = formal_ty.kind() {
-                    if self.root_var(*a) == self.root_var(*b) {
-                        formal_ty_idxs_matched.push(input_idx.into());
-                        if expected_ty_matched.is_none() {
-                            expected_ty_matched = Some(expected_ty);
-                        }
+            let mut idxs_matched: Vec<usize> = vec![];
+            for (other_idx, (_, _)) in params_with_generics.iter().enumerate().filter(
+                |(other_idx, (other_generic_param, _))| {
+                    if *other_idx == idx {
+                        return false;
                     }
-                }
+                    let Some(other_generic_param) = other_generic_param else {
+                        return false;
+                    };
+                    if matched_inputs[(*other_idx).into()].is_some() {
+                        return false;
+                    }
+                    other_generic_param.name.ident() == generic_param.name.ident()
+                },
+            ) {
+                idxs_matched.push(other_idx.into());
             }
 
-            let Some(expected_ty) = expected_ty_matched else {
+            if idxs_matched.len() == 0 {
                 continue;
-            };
-
-            let params = self
-                .tcx
-                .hir()
-                .get_if_local(def_id)
-                .and_then(|node| node.body_id())
-                .into_iter()
-                .flat_map(|id| self.tcx.hir().body(id).params);
-
-            let mut all_pats_matched: Vec<String> = vec![];
-            let mut incompatible_pats_matched: Vec<String> = vec![];
-            for (idx, param) in params
-                .into_iter()
-                .enumerate()
-                .filter(|(idx, _)| formal_ty_idxs_matched.contains(idx))
-            {
-                let ident = if let hir::PatKind::Binding(_, _, ident, _) = param.pat.kind {
-                    format!("`{ident}`")
-                } else {
-                    format!("`idx:{idx}`")
-                };
-                if matched_inputs[idx.into()].is_none() {
-                    incompatible_pats_matched.push(ident.clone());
-                }
-                all_pats_matched.push(ident);
             }
 
-            let expected_display_type =
-                self.resolve_vars_if_possible(*expected_ty).sort_string(self.tcx);
-            let label = if all_pats_matched.len() == 0 {
+            let expected_display_type = self
+                .resolve_vars_if_possible(formal_and_expected_inputs[idx.into()].1)
+                .sort_string(self.tcx);
+            let label = if idxs_matched.len() == params_with_generics.len() - 1 {
                 format!(
                     "expected all arguments to be {} because they need to match the type of this parameter",
                     expected_display_type
@@ -2558,7 +2512,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 )
             };
 
-            err.span_label(matched_arg_span, label);
+            err.span_label(*matched_arg_span, label);
         }
     }
 

tests/ui/async-await/coroutine-desc.stderr

@@ -5,7 +5,7 @@ LL |     fun(async {}, async {});
    |     --- --------  ^^^^^^^^ expected `async` block, found a different `async` block
    |     |   |
    |     |   the expected `async` block
-   |     |   expected some other arguments to be an `async` block to match the type of this parameter
+   |     |   expected all arguments to be `async` block because they need to match the type of this parameter
    |     arguments to this function are incorrect
    |
    = note: expected `async` block `{async block@$DIR/coroutine-desc.rs:10:9: 10:17}`
@@ -25,7 +25,7 @@ error[E0308]: mismatched types
 LL |     fun(one(), two());
    |     --- -----  ^^^^^ expected future, found a different future
    |     |   |
-   |     |   expected some other arguments to be a future to match the type of this parameter
+   |     |   expected all arguments to be future because they need to match the type of this parameter
    |     arguments to this function are incorrect
    |
    = help: consider `await`ing on both `Future`s
@@ -46,7 +46,7 @@ LL |     fun((async || {})(), (async || {})());
    |     --- ---------------  ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body
    |     |   |         |
    |     |   |         the expected `async` closure body
-   |     |   expected some other arguments to be an `async` closure body to match the type of this parameter
+   |     |   expected all arguments to be `async` closure body because they need to match the type of this parameter
    |     arguments to this function are incorrect
    |
    = note: expected `async` closure body `{async closure body@$DIR/coroutine-desc.rs:14:19: 14:21}`

tests/ui/coercion/coerce-reborrow-multi-arg-fail.stderr

@@ -4,7 +4,7 @@ error[E0308]: mismatched types
 LL |     test(&mut 7, &7);
    |     ---- ------  ^^ types differ in mutability
    |     |    |
-   |     |    expected some other arguments to be an `&mut {integer}` to match the type of this parameter
+   |     |    expected all arguments to be `&mut {integer}` because they need to match the type of this parameter
    |     arguments to this function are incorrect
    |
    = note: expected mutable reference `&mut {integer}`