Suggest removal of borrow in index when appropriate

When encountering

```rust
    let a = std::collections::HashMap::<String,String>::new();
    let s = "hello";
    let _b = &a[&s];
```
suggest `let _b = &a[s];`.

Fix rust-lang#66023.

Author: estebank

compiler/rustc_hir_typeck/src/expr.rs

@@ -2958,7 +2958,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // two-phase not needed because index_ty is never mutable
                     self.demand_coerce(idx, idx_t, index_ty, None, AllowTwoPhase::No);
                     self.select_obligations_where_possible(|errors| {
-                        self.point_at_index(errors, idx.span);
+                        self.point_at_index(errors, idx, expr, base, base_t);
                     });
                     element_ty
                 }
@@ -3131,7 +3131,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         .ok()
     }
 
-    fn point_at_index(&self, errors: &mut Vec<traits::FulfillmentError<'tcx>>, span: Span) {
+    fn point_at_index(
+        &self,
+        errors: &mut Vec<traits::FulfillmentError<'tcx>>,
+        idx: &'tcx hir::Expr<'tcx>,
+        expr: &'tcx hir::Expr<'tcx>,
+        base: &'tcx hir::Expr<'tcx>,
+        base_t: Ty<'tcx>,
+    ) {
+        let idx_span = idx.span;
         let mut seen_preds = FxHashSet::default();
         // We re-sort here so that the outer most root obligations comes first, as we have the
         // subsequent weird logic to identify *every* relevant obligation for proper deduplication
@@ -3155,7 +3163,39 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 (root, pred) if seen_preds.contains(&pred) || seen_preds.contains(&root) => {}
                 _ => continue,
             }
-            error.obligation.cause.span = span;
+            error.obligation.cause.span = idx_span;
+
+            // If the index value is a double borrow, that can cause typeck errors
+            // that can be easily resolved by removing the borrow from the expression.
+            // We check for that here and provide a suggestion in a custom obligation
+            // cause code.
+            if let hir::ExprKind::AddrOf(_, _, idx) = idx.kind {
+                let idx_t = self.typeck_results.borrow().expr_ty(idx);
+                if let Some((index_ty, _element_ty)) =
+                    self.lookup_indexing(expr, base, base_t, idx, idx_t)
+                {
+                    let (_ty, err) =
+                        self.demand_coerce_diag(idx, idx_t, index_ty, None, AllowTwoPhase::No);
+                    if let Some(err) = err {
+                        err.cancel();
+                    } else if self
+                        .fulfillment_cx
+                        .borrow_mut()
+                        .select_where_possible(self)
+                        .is_empty()
+                    {
+                        if let Some(pred) = error.obligation.predicate.to_opt_poly_trait_pred() {
+                            error.obligation.cause =
+                                error.obligation.cause.clone().derived_cause(pred, |cause| {
+                                    ObligationCauseCode::IndexExprDerivedObligation(Box::new((
+                                        cause,
+                                        idx_span.with_hi(idx.span.lo()),
+                                    )))
+                                });
+                        }
+                    }
+                }
+            }
         }
     }
 

compiler/rustc_middle/src/traits/mod.rs

@@ -331,6 +331,8 @@ pub enum ObligationCauseCode<'tcx> {
 
     DerivedObligation(DerivedObligationCause<'tcx>),
 
+    IndexExprDerivedObligation(Box<(DerivedObligationCause<'tcx>, Span)>),
+
     FunctionArgumentObligation {
         /// The node of the relevant argument in the function call.
         arg_hir_id: hir::HirId,

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -3399,6 +3399,25 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                     )
                 });
             }
+            ObligationCauseCode::IndexExprDerivedObligation(ref data) => {
+                ensure_sufficient_stack(|| {
+                    self.note_obligation_cause_code(
+                        body_id,
+                        err,
+                        predicate,
+                        param_env,
+                        &data.0.parent_code,
+                        obligated_types,
+                        seen_requirements,
+                    )
+                });
+                err.span_suggestion_verbose(
+                    data.1,
+                    "remove this borrow",
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+            }
             ObligationCauseCode::TypeAlias(ref nested, span, def_id) => {
                 // #74711: avoid a stack overflow
                 ensure_sufficient_stack(|| {

tests/ui/indexing/point-at-index-for-obligation-failure.fixed

@@ -0,0 +1,8 @@
+// run-rustfix
+fn main() {
+    let a = std::collections::HashMap::<String,String>::new();
+    let s = "hello";
+    let _b = &a[
+        s //~ ERROR E0277
+    ];
+}

tests/ui/indexing/point-at-index-for-obligation-failure.rs

@@ -1,7 +1,8 @@
+// run-rustfix
 fn main() {
     let a = std::collections::HashMap::<String,String>::new();
     let s = "hello";
-    let _b = a[
+    let _b = &a[
         &s //~ ERROR E0277
     ];
 }

tests/ui/indexing/point-at-index-for-obligation-failure.stderr

@@ -1,12 +1,17 @@
 error[E0277]: the trait bound `String: Borrow<&str>` is not satisfied
-  --> $DIR/point-at-index-for-obligation-failure.rs:5:9
+  --> $DIR/point-at-index-for-obligation-failure.rs:6:9
    |
 LL |         &s
    |         ^^ the trait `Borrow<&str>` is not implemented for `String`
    |
    = help: the trait `Borrow<str>` is implemented for `String`
    = help: for that trait implementation, expected `str`, found `&str`
    = note: required for `HashMap<String, String>` to implement `Index<&&str>`
+help: remove this borrow
+   |
+LL -         &s
+LL +         s
+   |
 
 error: aborting due to 1 previous error