Also suggest removing borrows

Author: sjwang05

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

@@ -838,57 +838,78 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                     }
                 }
             }
-        } else if let (ObligationCauseCode::BinOp { lhs_hir_id, .. }, predicate) =
+        } else if let (ObligationCauseCode::BinOp { lhs_hir_id, rhs_hir_id: Some(_rhs_hir_id), .. }, predicate) =
             code.peel_derives_with_predicate()
             && let hir::Node::Expr(lhs) = self.tcx.hir().get(*lhs_hir_id)
         {
             let trait_pred = predicate.unwrap_or(trait_pred);
             let lhs_ty = self.tcx.instantiate_bound_regions_with_erased(trait_pred.self_ty());
-            if let ty::Ref(..) = *lhs_ty.kind() {
-                let lhs_autoderef = (self.autoderef_steps)(lhs_ty);
-                if let Some(steps) =
-                    lhs_autoderef.into_iter().enumerate().find_map(|(steps, (ty, obligations))| {
-                        // Remapping bound vars here
-                        let trait_pred_and_ty =
-                            trait_pred.map_bound(|inner_trait_pred| (inner_trait_pred, ty));
-                        let obligation = self.mk_trait_obligation_with_new_self_ty(
-                            obligation.param_env,
-                            trait_pred_and_ty,
-                        );
+            let lhs_autoderef = (self.autoderef_steps)(lhs_ty);
+            if let Some(mut steps) =
+                lhs_autoderef.into_iter().enumerate().find_map(|(steps, (ty, obligations))| {
+                    // Remapping bound vars here
+                    let trait_pred_and_ty =
+                        trait_pred.map_bound(|inner_trait_pred| (inner_trait_pred, ty));
+                    let obligation = self.mk_trait_obligation_with_new_self_ty(
+                        obligation.param_env,
+                        trait_pred_and_ty,
+                    );
 
-                        let may_hold = obligations
-                            .iter()
-                            .chain([&obligation])
-                            .all(|obligation| self.predicate_may_hold(obligation))
-                            .then_some(steps);
+                    let may_hold = obligations
+                        .iter()
+                        .chain([&obligation])
+                        .all(|obligation| self.predicate_may_hold(obligation))
+                        .then_some(steps);
 
-                        may_hold
-                    })
-                {
-                    if steps > 0 {
-                        // Suggest `&&**` rather than `**&&`
-                        let span = lhs.peel_borrows().span;
-                        let derefs = "*".repeat(steps);
-                        let needs_parens = match lhs.kind {
+                    may_hold
+                })
+            {
+                if steps > 0 {
+                    // Suggest `&*` rather than `*&`
+                    let span = lhs.peel_borrows().span;
+
+                    let mut lhs = lhs;
+                    let mut prefix_span = lhs.span.shrink_to_lo();
+                    let mut msg = "consider dereferencing here";
+                    if let hir::ExprKind::AddrOf(_, _, inner) = lhs.kind {
+                        msg = "consider removing the borrow and dereferencing instead";
+                        if let hir::ExprKind::AddrOf(..) = inner.kind {
+                            msg = "consider removing the borrows and dereferencing instead";
+                        }
+                    }
+                    while let hir::ExprKind::AddrOf(_, _, inner) = lhs.kind
+                        && steps > 0
+                    {
+                        prefix_span = prefix_span.with_hi(inner.span.lo());
+                        lhs = inner;
+                        steps -= 1;
+                    }
+                    if steps == 0 {
+                        msg = msg.trim_end_matches(" and dereferencing instead");
+                    }
+
+                    let derefs = "*".repeat(steps);
+                    let needs_parens = steps > 0
+                        && match lhs.kind {
                             hir::ExprKind::Cast(_, _) | hir::ExprKind::Binary(_, _, _) => true,
                             _ if is_range_literal(lhs) => true,
                             _ => false,
                         };
-                        let suggestion = if needs_parens {
-                            vec![
-                                (span.shrink_to_lo(), format!("{derefs}(")),
-                                (span.shrink_to_hi(), ")".to_string()),
-                            ]
-                        } else {
-                            vec![(span.shrink_to_lo(), format!("{derefs}"))]
-                        };
-                        err.multipart_suggestion_verbose(
-                            "consider dereferencing here",
-                            suggestion,
-                            Applicability::MachineApplicable,
-                        );
-                        return true;
-                    }
+                    let mut suggestion = if needs_parens {
+                        vec![
+                            (span.shrink_to_lo(), format!("{derefs}(")),
+                            (span.shrink_to_hi(), ")".to_string()),
+                        ]
+                    } else {
+                        vec![(span.shrink_to_lo(), format!("{derefs}"))]
+                    };
+                    suggestion.push((prefix_span, "".to_string()));
+                    err.multipart_suggestion_verbose(
+                        msg,
+                        suggestion,
+                        Applicability::MachineApplicable,
+                    );
+                    return true;
                 }
             }
         }