Better error messages for &T == T

Something along the lines of "you are trying to compare a refference to to Type, try dereferencing first" would be nice, right now it just has the usual PartialEq not implemented.

Would the following output (as proposed in #40565) be enough to make the situation a bit more clear?

error[E0277]: the trait bound `&T: std::cmp::PartialEq<T>>` is not satisfied
  --> $DIR/file.rs:14:5
   |
14 |     &t == t;
   |     ^^^^^^^ can't compare `&T` with `T`

that would certainly improve things, but in this case the error message could be even more specific and thereby helpful by providing the information about deref-ing, so i would keep it as a separate issue, i think

Auto merge of #41559 - GuillaumeGomez:partial-eq-msg, r=estebank

Current output for:

fn main() {
    let x: usize = 3;
    let y: &usize = &3;
    if x == y {
        println!("asdf");
    }
    if y == x {
        println!("asdf");
    }
    if 3 == &3 {
        println!("asdf");
    }
    if &3 == 3 {
        println!("asdf");
    }
}

error[E0308]: mismatched types
 --> src/main.rs:4:13
  |
4 |     if x == y {
  |             ^
  |             |
  |             expected usize, found &usize
  |             help: consider dereferencing the borrow: `*y`
  |
  = note: expected type `usize`
             found type `&usize`

error[E0277]: the trait bound `&usize: std::cmp::PartialEq<usize>` is not satisfied
 --> src/main.rs:7:10
  |
7 |     if y == x {
  |          ^^ can't compare `&usize` with `usize`
  |
  = help: the trait `std::cmp::PartialEq<usize>` is not implemented for `&usize`

error[E0277]: the trait bound `{integer}: std::cmp::PartialEq<&{integer}>` is not satisfied
  --> src/main.rs:10:10
   |
10 |     if 3 == &3 {
   |          ^^ can't compare `{integer}` with `&{integer}`
   |
   = help: the trait `std::cmp::PartialEq<&{integer}>` is not implemented for `{integer}`

error[E0277]: the trait bound `&{integer}: std::cmp::PartialEq<{integer}>` is not satisfied
  --> src/main.rs:13:11
   |
13 |     if &3 == 3 {
   |           ^^ can't compare `&{integer}` with `{integer}`
   |
   = help: the trait `std::cmp::PartialEq<{integer}>` is not implemented for `&{integer}`

There's room for improvement.

Current output

error[E0308]: mismatched types
 --> src/main.rs:4:13
  |
4 |     if x == y {
  |             ^
  |             |
  |             expected usize, found &usize
  |             help: consider dereferencing the borrow: `*y`
  |
  = note: expected type `usize`
             found type `&usize`

error[E0277]: can't compare `&usize` with `usize`
 --> src/main.rs:7:10
  |
7 |     if y == x {
  |          ^^ no implementation for `&usize == usize`
  |
  = help: the trait `std::cmp::PartialEq<usize>` is not implemented for `&usize`

error[E0277]: can't compare `{integer}` with `&{integer}`
  --> src/main.rs:10:10
   |
10 |     if 3 == &3 {
   |          ^^ no implementation for `{integer} == &{integer}`
   |
   = help: the trait `std::cmp::PartialEq<&{integer}>` is not implemented for `{integer}`

error[E0277]: can't compare `&{integer}` with `{integer}`
  --> src/main.rs:13:11
   |
13 |     if &3 == 3 {
   |           ^^ no implementation for `&{integer} == {integer}`
   |
   = help: the trait `std::cmp::PartialEq<{integer}>` is not implemented for `&{integer}`

CC #45109, #60497, #57621, #52544, #39942, #44695.

Triage: current output is only slightly improved over previous output.

error[E0308]: mismatched types
 --> src/main.rs:4:13
  |
4 |     if x == y {
  |             ^
  |             |
  |             expected `usize`, found `&usize`
  |             help: consider dereferencing the borrow: `*y`

error[E0277]: can't compare `&usize` with `usize`
 --> src/main.rs:7:10
  |
7 |     if y == x {
  |          ^^ no implementation for `&usize == usize`
  |
  = help: the trait `PartialEq<usize>` is not implemented for `&usize`

error[E0277]: can't compare `{integer}` with `&{integer}`
  --> src/main.rs:10:10
   |
10 |     if 3 == &3 {
   |          ^^ no implementation for `{integer} == &{integer}`
   |
   = help: the trait `PartialEq<&{integer}>` is not implemented for `{integer}`

error[E0277]: can't compare `&{integer}` with `{integer}`
  --> src/main.rs:13:11
   |
13 |     if &3 == 3 {
   |           ^^ no implementation for `&{integer} == {integer}`
   |
   = help: the trait `PartialEq<{integer}>` is not implemented for `&{integer}`

It's not clear what should improve to make this better. Should we try to detect if T implements the trait and if so, suggest dereferencing &T?

Should we try to detect if T implements the trait and if so, suggest dereferencing &T?

Yes, I think we should do exactly that. I think that #57621, #52544 and #44695 cover that requirement as well (but lets keep them open and close in one sweep once we fix this).

Output with #90006:

error[E0308]: mismatched types
  --> f16.rs:18:13
   |
18 |     if x == y {
   |             ^ expected `usize`, found `&usize`
   |
help: consider dereferencing the borrow
   |
18 |     if x == *y {
   |             +

error[E0369]: can't compare `&usize` with `usize`
  --> f16.rs:21:10
   |
21 |     if y == x {
   |        - ^^ - usize
   |        |
   |        &usize
   |
help: `==` can be applied on `&usize`
   |
21 |     if y == &x {
   |             +
help: `==` can be used on `usize`, you can dereference `y`
   |
21 |     if *y == x {
   |        +

error[E0277]: can't compare `{integer}` with `&{integer}`
  --> f16.rs:24:10
   |
24 |     if 3 == &3 {
   |          ^^ no implementation for `{integer} == &{integer}`
   |
   = help: the trait `PartialEq<&{integer}>` is not implemented for `{integer}`

error[E0277]: can't compare `&{integer}` with `{integer}`
  --> f16.rs:27:11
   |
27 |     if &3 == 3 {
   |           ^^ no implementation for `&{integer} == {integer}`
   |
   = help: the trait `PartialEq<{integer}>` is not implemented for `&{integer}`

Another case that should be accounted for (from #67571):

struct MyType<T>
    where T: PartialEq,
{
    data: T,
}

impl<T> MyType<T>
    where T: PartialEq,
{
    fn write(&mut self, data: T) {
        self.data = data;
    }

    fn matches(&self, data: &T) -> bool {
        data == self.data
    }
}

fn main() {
    let foo: MyType<String> = MyType { data: String::from("ABC") };
    let bar = String::from("XYZ");

    if foo.matches(&bar) {
         println!("{:?}", bar);
    }    
}

Triage, few changes:

error[E0308]: mismatched types
 --> src/main.rs:4:13
  |
4 |     if x == y {
  |        -    ^ expected `usize`, found `&usize`
  |        |
  |        expected because this is `usize`
  |
help: consider dereferencing the borrow
  |
4 |     if x == *y {
  |             +

error[E0277]: can't compare `&usize` with `usize`
 --> src/main.rs:7:10
  |
7 |     if y == x {
  |          ^^ no implementation for `&usize == usize`
  |
  = help: the trait `PartialEq<usize>` is not implemented for `&usize`
  = help: the trait `PartialEq` is implemented for `usize`
  = help: for that trait implementation, expected `usize`, found `&usize`

error[E0277]: can't compare `{integer}` with `&{integer}`
  --> src/main.rs:10:10
   |
10 |     if 3 == &3 {
   |          ^^ no implementation for `{integer} == &{integer}`
   |
   = help: the trait `PartialEq<&{integer}>` is not implemented for `{integer}`
   = help: the following other types implement trait `PartialEq<Rhs>`:
             isize
             i8
             i16
             i32
             i64
             i128
             usize
             u8
           and 6 others

error[E0277]: can't compare `&{integer}` with `{integer}`
  --> src/main.rs:13:11
   |
13 |     if &3 == 3 {
   |           ^^ no implementation for `&{integer} == {integer}`
   |
   = help: the trait `PartialEq<{integer}>` is not implemented for `&{integer}`
   = help: the following other types implement trait `PartialEq<Rhs>`:
             isize
             i8
             i16
             i32
             i64
             i128
             usize
             u8
           and 6 others

@rustbot

I've gotten the output to look like this:

fn main() {
    let x: usize = 3;
    let y: &usize = &3;
    _ = y == x;
    _ = &y == x;
    _ = &&y == x;
    _ = 3 == &3;
    _ = &3 == 3;
}

error[E0277]: can't compare `&usize` with `usize`
 --> foo.rs:6:11
  |
6 |     _ = y == x;
  |           ^^ no implementation for `&usize == usize`
  |
  = help: the trait `PartialEq<usize>` is not implemented for `&usize`
help: consider dereferencing here
  |
6 |     _ = *y == x;
  |         +

error[E0277]: can't compare `&&usize` with `usize`        
 --> foo.rs:7:12
  |
7 |     _ = &y == x;
  |            ^^ no implementation for `&&usize == usize`
  |
  = help: the trait `PartialEq<usize>` is not implemented for `&&usize`
help: consider removing the borrow and dereferencing instead
  |
7 -     _ = &y == x;
7 +     _ = *y == x;
  |

error[E0277]: can't compare `&&&usize` with `usize`
 --> foo.rs:8:13
  |
8 |     _ = &&y == x;
  |             ^^ no implementation for `&&&usize == usize`
  |
  = help: the trait `PartialEq<usize>` is not implemented for `&&&usize`
help: consider removing the borrows and dereferencing instead
  |
8 -     _ = &&y == x;
8 +     _ = *y == x;
  |

error[E0277]: can't compare `{integer}` with `&{integer}`
 --> foo.rs:9:11
  |
9 |     _ = 3 == &3;
  |           ^^ no implementation for `{integer} == &{integer}`
  |
  = help: the trait `PartialEq<&{integer}>` is not implemented for `{integer}`
  = help: the following other types implement trait `PartialEq<Rhs>`:
            isize
            i8
            i16
            i32
            i64
            i128
            usize
            u8
          and 6 others

error[E0277]: can't compare `&{integer}` with `{integer}`
  --> foo.rs:10:12
   |
10 |     _ = &3 == 3;
   |            ^^ no implementation for `&{integer} == {integer}`
   |
   = help: the trait `PartialEq<{integer}>` is not implemented for `&{integer}`
help: consider removing the borrow
   |
10 -     _ = &3 == 3;
10 +     _ = 3 == 3;
   |

error: aborting due to 5 previous errors

For more information about this error, try `rustc --explain E0277`.

I'll see if I can get Rhs suggestions working.

@rustbot claim

@sjwang05

@sjwang05 if you make a new ObligationCauseCode you should be able to keep both lhs and rhs in it to do this.

Storing the lhs and rhs HirIds in ObligationCauseCode::BinOp did the trick. Thanks!

Auto merge of rust-lang#118431 - sjwang05:issue-44695, r=estebank

Navigation Menu

Repository navigation

Better error messages for &T == T #40660

1 remaining item

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Better error messages for &T == T #40660

Description

Activity

estebank commented on Mar 21, 2017

iqualfragile commented on Mar 21, 2017

estebank commented on Dec 6, 2017

estebank commented on Mar 8, 2019

estebank commented on Sep 26, 2019

1 remaining item

rylev commented on Dec 9, 2020

estebank commented on Jan 12, 2021

estebank commented on Oct 18, 2021

estebank commented on Nov 17, 2023

estebank commented on Nov 17, 2023

sjwang05 commented on Nov 28, 2023

estebank commented on Nov 28, 2023

sjwang05 commented on Nov 29, 2023

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions