Update tests

Author: sjwang05

tests/ui/binop/binary-op-suggest-deref.fixed

@@ -1,8 +1,75 @@
-// Issue #52544
-// run-rustfix
+#![allow(dead_code)]
 
-fn main() {
+fn foo() {
+    // Issue #52544
     let i: &i64 = &1;
     if i < 0 {}
     //~^ ERROR mismatched types [E0308]
 }
+
+fn bar() {
+    // Issue #40660
+    let foo = &&0;
+
+    // Dereference LHS
+    _ = foo == 0;
+    //~^ERROR can't compare `&&{integer}` with `{integer}` [E0277]
+    _ = foo == &0;
+    //~^ERROR can't compare `&{integer}` with `{integer}` [E0277]
+    _ = &&&&foo == 0;
+    //~^ERROR can't compare `&&&&&&{integer}` with `{integer}` [E0277]
+    _ = *foo == 0;
+    //~^ERROR can't compare `&{integer}` with `{integer}` [E0277]
+    _ = &&foo == &&0;
+    //~^ERROR can't compare `&&{integer}` with `{integer}` [E0277]
+    _ = &Box::new(42) == 42;
+    //~^ERROR can't compare `&Box<{integer}>` with `{integer}` [E0277]
+    _ = &Box::new(&Box::new(&42)) == 42;
+    //~^ERROR can't compare `&Box<&Box<&{integer}>>` with `{integer}` [E0277]
+
+    // Dereference RHS
+    _ = 0 == foo;
+    //~^ERROR can't compare `{integer}` with `&&{integer}` [E0277]
+    _ = &0 == foo;
+    //~^ERROR can't compare `{integer}` with `&{integer}` [E0277]
+    _ = 0 == &&&&foo;
+    //~^ERROR can't compare `{integer}` with `&&&&&&{integer}` [E0277]
+    _ = 0 == *foo;
+    //~^ERROR can't compare `{integer}` with `&{integer}` [E0277]
+    _ = &&0 == &&foo;
+    //~^ERROR can't compare `{integer}` with `&&{integer}` [E0277]
+
+    // Dereference both sides
+    _ = &Box::new(Box::new(42)) == &foo;
+    //~^ERROR can't compare `Box<Box<{integer}>>` with `&&{integer}` [E0277]
+    _ = &Box::new(42) == &foo;
+    //~^ERROR can't compare `Box<{integer}>` with `&&{integer}` [E0277]
+    _ = &Box::new(Box::new(Box::new(Box::new(42)))) == &foo;
+    //~^ERROR can't compare `Box<Box<Box<Box<{integer}>>>>` with `&&{integer}` [E0277]
+    _ = &foo == &Box::new(Box::new(Box::new(Box::new(42))));
+    //~^ERROR can't compare `&&{integer}` with `Box<Box<Box<Box<{integer}>>>>` [E0277]
+
+    // Don't suggest dereferencing the LHS; suggest boxing the RHS instead
+    _ = Box::new(42) == 42;
+    //~^ERROR mismatched types [E0308]
+
+    // Don't suggest dereferencing with types that can't be compared
+    struct Foo;
+    _ = &&0 == Foo;
+    //~^ERROR can't compare `&&{integer}` with `Foo` [E0277]
+    _ = Foo == &&0;
+    //~^ERROR binary operation `==` cannot be applied to type `Foo` [E0369]
+}
+
+fn baz() {
+    // Issue #44695
+    let owned = "foo".to_owned();
+    let string_ref = &owned;
+    let partial = "foobar";
+    _ = string_ref == partial[..3];
+    //~^ERROR can't compare `&String` with `str` [E0277]
+    _ = partial[..3] == string_ref;
+    //~^ERROR can't compare `str` with `&String` [E0277]
+}
+
+fn main() {}

tests/ui/binop/binary-op-suggest-deref.rs

@@ -1,5 +1,3 @@
-// run-rustfix
-
 pub struct Bytes;
 
 impl Bytes {

tests/ui/binop/binary-op-suggest-deref.stderr

@@ -15,6 +15,11 @@ LL |     let _ = &[0u8] == [0xAA];
              <[B] as PartialEq<[A; N]>>
              <&[u8] as PartialEq<Bytes>>
            and 4 others
+help: consider removing the borrow
+   |
+LL -     let _ = &[0u8] == [0xAA];
+LL +     let _ = [0u8] == [0xAA];
+   |
 help: convert the array to a `&[u8]` slice instead
    |
 LL |     let _ = &[0u8] == &[0xAA][..];

tests/ui/dst/issue-113447.fixed

@@ -5,6 +5,10 @@ LL |     a == b;
    |       ^^ no implementation for `&T == T`
    |
    = help: the trait `PartialEq<T>` is not implemented for `&T`
+help: consider dereferencing here
+   |
+LL |     *a == b;
+   |     +
 help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
    |
 LL | fn foo<T: PartialEq>(a: &T, b: T) where &T: PartialEq<T> {
@@ -17,6 +21,10 @@ LL |     a == b;
    |       ^^ no implementation for `&T == T`
    |
    = help: the trait `PartialEq<T>` is not implemented for `&T`
+help: consider dereferencing here
+   |
+LL |     *a == b;
+   |     +
 help: consider extending the `where` clause, but there might be an alternative better way to express this requirement
    |
 LL | fn foo2<T: PartialEq>(a: &T, b: T) where &T: PartialEq<T> {