Suggest swapping LHS and RHS for PartialEq

Author: makai410

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -3390,4 +3390,33 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             err.span_label(block.span, "this block is missing a tail expression");
         }
     }
+
+    pub(crate) fn suggest_swapping_lhs_and_rhs(
+        &self,
+        err: &mut Diag<'_>,
+        checked_ty: Ty<'tcx>,
+        expected_ty_expr: &'tcx hir::Expr<'tcx>,
+        op: hir::BinOp,
+    ) {
+        match op.node {
+            hir::BinOpKind::Eq => {
+                if let Some(partial_eq_def_id) = self.infcx.tcx.lang_items().eq_trait()
+                    && let lhs_ty = self.check_expr(expected_ty_expr)
+                    && self
+                        .infcx
+                        .type_implements_trait(
+                            partial_eq_def_id,
+                            [checked_ty, lhs_ty],
+                            self.param_env,
+                        )
+                        .must_apply_modulo_regions()
+                {
+                    let trait_name = self.infcx.tcx.item_name(partial_eq_def_id);
+                    err.note(format!("`{}` implements `{}<{}>`", checked_ty, trait_name, lhs_ty));
+                    err.help(format!("consider swapping the LHS and RHS of the equality"));
+                }
+            }
+            _ => {}
+        }
+    }
 }

compiler/rustc_hir_typeck/src/op.rs

@@ -198,6 +198,29 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    fn check_expr_coercible_to_type_or_error(
+        &self,
+        expr: &'tcx hir::Expr<'tcx>,
+        expected: Ty<'tcx>,
+        expected_ty_expr: &'tcx hir::Expr<'tcx>,
+        op: hir::BinOp,
+    ) -> Ty<'tcx> {
+        let ty = self.check_expr_with_hint(expr, expected);
+        // checks don't need two phase
+        match self.demand_coerce_diag(expr, ty, expected, Some(expected_ty_expr), AllowTwoPhase::No)
+        {
+            Ok(ty) => ty,
+            Err(mut err) => {
+                self.suggest_swapping_lhs_and_rhs(&mut err, ty, expected_ty_expr, op);
+                err.emit();
+                // Return the original type instead of an error type here, otherwise the type of `x` in
+                // `let x: u32 = ();` will be a type error, causing all subsequent usages of `x` to not
+                // report errors, even though `x` is definitely `u32`.
+                expected
+            }
+        }
+    }
+
     fn check_overloaded_binop(
         &self,
         expr: &'tcx hir::Expr<'tcx>,
@@ -249,7 +272,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         );
 
         // see `NB` above
-        let rhs_ty = self.check_expr_coercible_to_type(rhs_expr, rhs_ty_var, Some(lhs_expr));
+        let rhs_ty = self.check_expr_coercible_to_type_or_error(rhs_expr, rhs_ty_var, lhs_expr, op);
         let rhs_ty = self.resolve_vars_with_obligations(rhs_ty);
 
         let return_ty = match result {