Use a stack to store rvcr_type and match up with span

Author: iSwapna

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1239,12 +1239,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
         }
-        // Only if an appropriate error source is not found, check method chain for possible candiates
-        let error_source_not_found = unsatisfied_predicates.is_empty();
-        if error_source_not_found && let Mode::MethodCall = mode && let SelfSource::MethodCall(mut source_expr) = source {
-        while let hir::ExprKind::MethodCall(_path_segment, rcvr_expr, _args, _span) =
-        source_expr.kind
+        // If an appropriate error source is not found, check method chain for possible candiates
+        if unsatisfied_predicates.is_empty() && let Mode::MethodCall = mode && let SelfSource::MethodCall(mut source_expr) = source {
+            let mut stack_methods = vec![];
+            while let hir::ExprKind::MethodCall(_path_segment, rcvr_expr, _args, method_span) =
+            source_expr.kind
             {
+                 // Pop the matching receiver, to align on it's notional span
+                 if let Some(prev_match) = stack_methods.pop() {
+                    err.span_label(method_span, format!("{item_kind} `{item_name}` is available on `{prev_match}`"));
+                }
                 let rcvr_ty = self.resolve_vars_if_possible(
                     self.typeck_results
                         .borrow()
@@ -1259,10 +1263,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     rcvr_ty,
                     source_expr.hir_id,
                     ProbeScope::TraitsInScope,) {
-                        err.span_label(rcvr_expr.span, format!("{item_kind} `{item_name}` is available on `{rcvr_ty}`"));
-                    }
-                    source_expr = rcvr_expr;
-
+                        // found a match, push to stack
+                        stack_methods.push(rcvr_ty);
+                }
+                source_expr = rcvr_expr;
+            }
+            // If there is a match at the start of the chain, add a label for it too!
+            if let Some(prev_match) = stack_methods.pop() {
+                err.span_label(source_expr.span, format!("{item_kind} `{item_name}` is available on `{prev_match}`"));
             }
         }
         self.note_derefed_ty_has_method(&mut err, source, rcvr_ty, item_name, expected);

tests/ui/structs/method-chain-expression-failure.rs

@@ -2,25 +2,31 @@ struct A;
 struct B;
 struct C;
 struct D;
+struct E;
 
 impl A {
     fn b(&self) -> B { B }
+    fn foo(&self) {}
 }
 
 impl B {
     fn c(&self) -> C { C }
-    fn foo(&self) {}
 }
 
 impl C {
     fn d(&self) -> D { D }
+    fn foo(&self) {}
 }
 
 impl D {
-    fn e(&self) {}
+    fn e(&self) -> E { E }
 }
 
+impl E {
+    fn f(&self) {}
+}
 fn main() {
-    A.b().c().d().foo();
-//~^ ERROR no method named `foo` found for struct `D` in the current scope
+    A.b().c().d().e().foo();
+//~^ ERROR no method named `foo` found for struct `E` in the current scope
 }
+

tests/ui/structs/method-chain-expression-failure.stderr

@@ -1,13 +1,14 @@
-error[E0599]: no method named `foo` found for struct `D` in the current scope
-  --> $DIR/method-chain-expression-failure.rs:24:19
+error[E0599]: no method named `foo` found for struct `E` in the current scope
+  --> $DIR/method-chain-expression-failure.rs:29:23
    |
-LL | struct D;
+LL | struct E;
    | -------- method `foo` not found for this struct
 ...
-LL |     A.b().c().d().foo();
-   |     -----         ^^^ method not found in `D`
-   |     |
-   |     method `foo` is available on `&B`
+LL |     A.b().c().d().e().foo();
+   |     -     ---         ^^^ method not found in `E`
+   |     |     |
+   |     |     method `foo` is available on `&C`
+   |     method `foo` is available on `&A`
 
 error: aborting due to previous error
 

tests/ui/suggestions/chain-method-call-mutation-in-place.stderr

@@ -18,10 +18,10 @@ error[E0599]: no method named `sort` found for unit type `()` in the current sco
   --> $DIR/chain-method-call-mutation-in-place.rs:3:72
    |
 LL |     vec![1, 2, 3].into_iter().collect::<Vec<i32>>().sort_by_key(|i| i).sort();
-   |                   -----------                       ------------------ ^^^^ method not found in `()`
-   |                   |                                 |
-   |                   |                                 method `sort` is available on `&mut [i32]`
-   |                   method `sort` is available on `Vec<i32>`
+   |     -------------             ---------------------                    ^^^^ method not found in `()`
+   |     |                         |
+   |     |                         method `sort` is available on `&mut [i32]`
+   |     method `sort` is available on `Vec<i32>`
    |
 note: method `sort_by_key` modifies its receiver in-place, it is not meant to be used in method chains.
   --> $DIR/chain-method-call-mutation-in-place.rs:3:53