PR Feedback; find alternate way to get the appropriate span

Author: Jamesbarford

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -2975,7 +2975,6 @@ impl<'a, 'b, 'tcx> ArgsCtxt<'a, 'b, 'tcx> {
                 IsSuggestion(true),
                 callee_ty.peel_refs(),
                 self.call_ctxt.callee_expr.unwrap().hir_id,
-                None,
                 TraitsInScope,
                 |mut ctxt| ctxt.probe_for_similar_candidate(),
             )

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -1794,7 +1794,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         self_ty,
                         expr.hir_id,
                         ProbeScope::TraitsInScope,
-                        Some(expr.span),
                     )
                 {
                     (pick.item, segment)

compiler/rustc_hir_typeck/src/method/mod.rs

@@ -104,7 +104,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self_ty,
             call_expr_id,
             ProbeScope::TraitsInScope,
-            None,
         ) {
             Ok(pick) => {
                 pick.maybe_emit_unstable_name_collision_hint(
@@ -189,7 +188,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             ProbeScope::TraitsInScope
         };
 
-        let pick = self.lookup_probe(segment.ident, self_ty, call_expr, self_expr, scope)?;
+        let pick = self.lookup_probe(segment.ident, self_ty, call_expr, scope)?;
 
         self.lint_edition_dependent_dot_call(
             self_ty, segment, span, call_expr, self_expr, &pick, args,
@@ -216,7 +215,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     segment.ident,
                     trait_type,
                     call_expr,
-                    self_expr,
                     ProbeScope::TraitsInScope,
                 ) {
                     Ok(ref new_pick) if pick.differs_from(new_pick) => {
@@ -285,7 +283,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         method_name: Ident,
         self_ty: Ty<'tcx>,
         call_expr: &hir::Expr<'_>,
-        self_expr: &hir::Expr<'_>,
         scope: ProbeScope,
     ) -> probe::PickResult<'tcx> {
         let pick = self.probe_for_name(
@@ -296,7 +293,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self_ty,
             call_expr.hir_id,
             scope,
-            Some(self_expr.span),
         )?;
 
         pick.maybe_emit_unstable_name_collision_hint(self.tcx, method_name.span, call_expr.hir_id);
@@ -319,7 +315,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self_ty,
             call_expr.hir_id,
             scope,
-            None,
         )?;
         Ok(pick)
     }
@@ -539,7 +534,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self_ty,
             expr_id,
             ProbeScope::TraitsInScope,
-            Some(self_ty_span),
         );
         let pick = match (pick, struct_variant) {
             // Fall back to a resolution that will produce an error later.

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -7,9 +7,8 @@ use rustc_attr_parsing::is_doc_alias_attrs_contain_symbol;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sso::SsoHashSet;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::HirId;
 use rustc_hir::def::DefKind;
+use rustc_hir::{self as hir, ExprKind, HirId, Node};
 use rustc_hir_analysis::autoderef::{self, Autoderef};
 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk, TyCtxtInferExt};
@@ -296,7 +295,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 IsSuggestion(true),
                 self_ty,
                 scope_expr_id,
-                None,
                 ProbeScope::AllTraits,
                 |probe_cx| Ok(probe_cx.candidate_method_names(candidate_filter)),
             )
@@ -312,7 +310,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     IsSuggestion(true),
                     self_ty,
                     scope_expr_id,
-                    None,
                     ProbeScope::AllTraits,
                     |probe_cx| probe_cx.pick(),
                 )
@@ -332,7 +329,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self_ty: Ty<'tcx>,
         scope_expr_id: HirId,
         scope: ProbeScope,
-        self_expr_span: Option<Span>,
     ) -> PickResult<'tcx> {
         self.probe_op(
             item_name.span,
@@ -342,7 +338,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             is_suggestion,
             self_ty,
             scope_expr_id,
-            self_expr_span,
             scope,
             |probe_cx| probe_cx.pick(),
         )
@@ -367,7 +362,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             is_suggestion,
             self_ty,
             scope_expr_id,
-            None,
             scope,
             |probe_cx| {
                 Ok(probe_cx
@@ -388,7 +382,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         is_suggestion: IsSuggestion,
         self_ty: Ty<'tcx>,
         scope_expr_id: HirId,
-        self_expr: Option<Span>,
         scope: ProbeScope,
         op: OP,
     ) -> Result<R, MethodError<'tcx>>
@@ -492,12 +485,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let ty = self.resolve_vars_if_possible(ty.value);
                 let guar = match *ty.kind() {
                     ty::Infer(ty::TyVar(_)) => {
+                        // We want to get the variable name that the method
+                        // is being called on. If it is a method call.
+                        let err_span = match (mode, self.tcx.hir_node(scope_expr_id)) {
+                            (
+                                Mode::MethodCall,
+                                Node::Expr(hir::Expr {
+                                    kind: ExprKind::MethodCall(_, recv, ..),
+                                    ..
+                                }),
+                            ) => recv.span,
+                            _ => span,
+                        };
+
                         let raw_ptr_call = bad_ty.reached_raw_pointer
                             && !self.tcx.features().arbitrary_self_types();
 
                         let mut err = self.err_ctxt().emit_inference_failure_err(
                             self.body_id,
-                            self_expr.unwrap_or(span),
+                            err_span,
                             ty.into(),
                             TypeAnnotationNeeded::E0282,
                             !raw_ptr_call,

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -2114,7 +2114,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             rcvr_ty,
                             expr_id,
                             ProbeScope::TraitsInScope,
-                            None,
                         )
                         .is_ok()
             })
@@ -3177,7 +3176,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 deref_ty,
                 ty.hir_id,
                 ProbeScope::TraitsInScope,
-                None,
             ) {
                 if deref_ty.is_suggestable(self.tcx, true)
                     // If this method receives `&self`, then the provided