Suggest swapping LHS and RHS of equality

Author: makai410

compiler/rustc_hir_typeck/src/expr.rs

@@ -102,10 +102,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expr: &'tcx hir::Expr<'tcx>,
         expected: Ty<'tcx>,
         expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
+    ) -> Ty<'tcx> {
+        self.check_expr_coercible_to_type_or_error(expr, expected, expected_ty_expr, |_| {})
+    }
+
+    pub(crate) fn check_expr_coercible_to_type_or_error(
+        &self,
+        expr: &'tcx hir::Expr<'tcx>,
+        expected: Ty<'tcx>,
+        expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
+        extend_err: impl FnOnce(&mut Diag<'_>),
     ) -> Ty<'tcx> {
         let ty = self.check_expr_with_hint(expr, expected);
         // checks don't need two phase
-        self.demand_coerce(expr, ty, expected, expected_ty_expr, AllowTwoPhase::No)
+        match self.demand_coerce_diag(expr, ty, expected, expected_ty_expr, AllowTwoPhase::No) {
+            Ok(ty) => ty,
+            Err(mut err) => {
+                extend_err(&mut err);
+                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
+            }
+        }
     }
 
     pub(super) fn check_expr_with_hint(

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

@@ -249,7 +249,15 @@ 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,
+            Some(lhs_expr),
+            |err| {
+                let ty = self.check_expr_with_hint(rhs_expr, rhs_ty_var);
+                self.suggest_swapping_lhs_and_rhs(err, ty, lhs_expr, op);
+            },
+        );
         let rhs_ty = self.resolve_vars_with_obligations(rhs_ty);
 
         let return_ty = match result {

tests/ui/partialeq_suggest_swap.rs

@@ -0,0 +1,11 @@
+struct T(i32);
+
+impl PartialEq<i32> for T {
+    fn eq(&self, other: &i32) -> bool {
+        &self.0 == other
+    }
+}
+
+fn main() {
+    4i32 == T(4); //~ ERROR E0308
+}

tests/ui/partialeq_suggest_swap.stderr

@@ -0,0 +1,14 @@
+error[E0308]: mismatched types
+  --> $DIR/partialeq_suggest_swap.rs:10:13
+   |
+LL |     4i32 == T(4);
+   |     ----    ^^^^ expected `i32`, found `T`
+   |     |
+   |     expected because this is `i32`
+   |
+   = note: `T` implements `PartialEq<i32>`
+   = help: consider swapping the LHS and RHS of the equality
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.