Improve diag when calling method on result of index op

Author: mu001999

compiler/rustc_hir_typeck/src/expr.rs

@@ -36,6 +36,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_hir::{ExprKind, HirId, QPath};
 use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer as _;
 use rustc_infer::infer;
+use rustc_infer::infer::error_reporting::TypeAnnotationNeeded::E0282;
 use rustc_infer::infer::DefineOpaqueTypes;
 use rustc_infer::infer::InferOk;
 use rustc_infer::traits::query::NoSolution;
@@ -1330,7 +1331,35 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ) -> Ty<'tcx> {
         let rcvr_t = self.check_expr(rcvr);
         // no need to check for bot/err -- callee does that
-        let rcvr_t = self.structurally_resolve_type(rcvr.span, rcvr_t);
+        let rcvr_t = if let ExprKind::Index(_, index, _) = rcvr.kind {
+            let ty = self.try_structurally_resolve_type(rcvr.span, rcvr_t);
+
+            if !ty.is_ty_var() {
+                ty
+            } else {
+                let e = self
+                    .tainted_by_errors()
+                    .or_else(|| self.report_ambiguity_errors())
+                    .unwrap_or_else(|| {
+                        self.err_ctxt()
+                            .emit_inference_failure_err(
+                                self.body_id,
+                                index.span,
+                                ty.into(),
+                                E0282,
+                                true,
+                            )
+                            .emit()
+                    });
+
+                let err = Ty::new_error(self.tcx, e);
+                self.demand_suptype(rcvr.span, err, ty);
+                err
+            }
+        } else {
+            self.structurally_resolve_type(rcvr.span, rcvr_t)
+        };
+
         let span = segment.ident.span;
 
         let method = match self.lookup_method(rcvr_t, segment, span, expr, rcvr, args) {

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -589,18 +589,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     #[instrument(skip(self), level = "debug")]
-    pub(crate) fn report_ambiguity_errors(&self) {
+    pub(crate) fn report_ambiguity_errors(&self) -> Option<ErrorGuaranteed> {
         let mut errors = self.fulfillment_cx.borrow_mut().collect_remaining_errors(self);
 
-        if !errors.is_empty() {
-            self.adjust_fulfillment_errors_for_expr_obligation(&mut errors);
-            let errors_causecode = errors
-                .iter()
-                .map(|e| (e.obligation.cause.span, e.root_obligation.cause.code().clone()))
-                .collect::<Vec<_>>();
-            self.err_ctxt().report_fulfillment_errors(errors);
-            self.collect_unused_stmts_for_coerce_return_ty(errors_causecode);
+        if errors.is_empty() {
+            return None;
         }
+
+        self.adjust_fulfillment_errors_for_expr_obligation(&mut errors);
+        let errors_causecode = errors
+            .iter()
+            .map(|e| (e.obligation.cause.span, e.root_obligation.cause.code().clone()))
+            .collect::<Vec<_>>();
+        let e = self.err_ctxt().report_fulfillment_errors(errors);
+        self.collect_unused_stmts_for_coerce_return_ty(errors_causecode);
+        Some(e)
     }
 
     /// Select as many obligations as we can at present.

tests/ui/inference/need_type_info/calling-method-on-result-of-index-op-issue-125924.rs

@@ -0,0 +1,13 @@
+struct Foo;
+
+impl Foo {
+    fn foo(&self) {}
+}
+
+fn main() {
+    let thing: Vec<Foo> = vec![];
+
+    let foo = |i| { //~ ERROR type annotations needed
+        thing[i].foo();
+    };
+}

tests/ui/inference/need_type_info/calling-method-on-result-of-index-op-issue-125924.stderr

@@ -0,0 +1,18 @@
+error[E0283]: type annotations needed
+  --> $DIR/calling-method-on-result-of-index-op-issue-125924.rs:10:16
+   |
+LL |     let foo = |i| {
+   |                ^
+LL |         thing[i].foo();
+   |         -------- type must be known at this point
+   |
+   = note: cannot satisfy `_: SliceIndex<[Foo]>`
+   = note: required for `Vec<Foo>` to implement `Index<_>`
+help: consider giving this closure parameter an explicit type
+   |
+LL |     let foo = |i: /* Type */| {
+   |                 ++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0283`.