@@ -440,30 +440,29 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
440440 call_expr : & hir:: Expr < ' tcx > ,
441441 ) {
442442 // Next, let's construct the error
443- let ( error_span, full_call_span, ctor_of) = match & call_expr. kind {
443+ let ( error_span, full_call_span, ctor_of, is_method ) = match & call_expr. kind {
444444 hir:: ExprKind :: Call (
445445 hir:: Expr { hir_id, span, kind : hir:: ExprKind :: Path ( qpath) , .. } ,
446446 _,
447447 ) => {
448448 if let Res :: Def ( DefKind :: Ctor ( of, _) , _) =
449449 self . typeck_results . borrow ( ) . qpath_res ( qpath, * hir_id)
450450 {
451- ( call_span, * span, Some ( of) )
451+ ( call_span, * span, Some ( of) , false )
452452 } else {
453- ( call_span, * span, None )
453+ ( call_span, * span, None , false )
454454 }
455455 }
456- hir:: ExprKind :: Call ( hir:: Expr { span, .. } , _) => ( call_span, * span, None ) ,
456+ hir:: ExprKind :: Call ( hir:: Expr { span, .. } , _) => ( call_span, * span, None , false ) ,
457457 hir:: ExprKind :: MethodCall ( path_segment, _, span) => {
458458 let ident_span = path_segment. ident . span ;
459459 let ident_span = if let Some ( args) = path_segment. args {
460460 ident_span. with_hi ( args. span_ext . hi ( ) )
461461 } else {
462462 ident_span
463463 } ;
464- (
465- * span, ident_span, None , // methods are never ctors
466- )
464+ // methods are never ctors
465+ ( * span, ident_span, None , true )
467466 }
468467 k => span_bug ! ( call_span, "checking argument types on a non-call: `{:?}`" , k) ,
469468 } ;
@@ -659,7 +658,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
659658 Applicability :: MachineApplicable ,
660659 ) ;
661660 } ;
662- self . label_fn_like ( & mut err, fn_def_id, callee_ty) ;
661+ self . label_fn_like ( & mut err, fn_def_id, callee_ty, Some ( mismatch_idx ) , is_method ) ;
663662 err. emit ( ) ;
664663 return ;
665664 }
@@ -701,16 +700,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
701700 }
702701
703702 errors. drain_filter ( |error| {
704- let Error :: Invalid ( provided_idx, expected_idx, Compatibility :: Incompatible ( error ) ) = error else { return false } ;
703+ let Error :: Invalid ( provided_idx, expected_idx, Compatibility :: Incompatible ( Some ( e ) ) ) = error else { return false } ;
705704 let ( provided_ty, provided_span) = provided_arg_tys[ * provided_idx] ;
706705 let ( expected_ty, _) = formal_and_expected_inputs[ * expected_idx] ;
707706 let cause = & self . misc ( provided_span) ;
708707 let trace = TypeTrace :: types ( cause, true , expected_ty, provided_ty) ;
709- if let Some ( e) = error {
710- if !matches ! ( trace. cause. as_failure_code( e) , FailureCode :: Error0308 ( _) ) {
711- self . report_and_explain_type_error ( trace, e) . emit ( ) ;
712- return true ;
713- }
708+ if !matches ! ( trace. cause. as_failure_code( e) , FailureCode :: Error0308 ( _) ) {
709+ self . report_and_explain_type_error ( trace, e) . emit ( ) ;
710+ return true ;
714711 }
715712 false
716713 } ) ;
@@ -749,7 +746,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
749746 format ! ( "arguments to this {} are incorrect" , call_name) ,
750747 ) ;
751748 // Call out where the function is defined
752- self . label_fn_like ( & mut err, fn_def_id, callee_ty) ;
749+ self . label_fn_like ( & mut err, fn_def_id, callee_ty, Some ( expected_idx . as_usize ( ) ) , is_method ) ;
753750 err. emit ( ) ;
754751 return ;
755752 }
@@ -1031,7 +1028,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
10311028 }
10321029
10331030 // Call out where the function is defined
1034- self . label_fn_like ( & mut err, fn_def_id, callee_ty) ;
1031+ self . label_fn_like ( & mut err, fn_def_id, callee_ty, None , is_method ) ;
10351032
10361033 // And add a suggestion block for all of the parameters
10371034 let suggestion_text = match suggestion_text {
@@ -1781,6 +1778,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
17811778 err : & mut Diagnostic ,
17821779 callable_def_id : Option < DefId > ,
17831780 callee_ty : Option < Ty < ' tcx > > ,
1781+ // A specific argument should be labeled, instead of all of them
1782+ expected_idx : Option < usize > ,
1783+ is_method : bool ,
17841784 ) {
17851785 let Some ( mut def_id) = callable_def_id else {
17861786 return ;
@@ -1881,10 +1881,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
18811881 . get_if_local ( def_id)
18821882 . and_then ( |node| node. body_id ( ) )
18831883 . into_iter ( )
1884- . flat_map ( |id| self . tcx . hir ( ) . body ( id) . params ) ;
1884+ . flat_map ( |id| self . tcx . hir ( ) . body ( id) . params )
1885+ . skip ( if is_method { 1 } else { 0 } ) ;
18851886
1886- for param in params {
1887- spans. push_span_label ( param. span , "" ) ;
1887+ for ( idx, param) in params. into_iter ( ) . enumerate ( ) {
1888+ if let Some ( expected_idx) = expected_idx {
1889+ if idx == expected_idx {
1890+ spans. push_span_label ( param. span , "" ) ;
1891+ }
1892+ } else {
1893+ spans. push_span_label ( param. span , "" ) ;
1894+ }
18881895 }
18891896
18901897 let def_kind = self . tcx . def_kind ( def_id) ;
0 commit comments