redundant_clone: false positive in equality comparison

[ebroto]

#[derive(PartialEq)]
struct Foo;

struct Bar;

impl ToOwned for Bar {
    type Owned = Foo;
    fn to_owned(&self) -> Foo {
        Foo {}
    }
}

impl std::borrow::Borrow<Bar> for Foo {
    fn borrow(&self) -> &Bar {
        static BAR: Bar = Bar {};
        &BAR
    }
}

fn main() {
    let f = Foo {};
    let b = Bar {};

    if f == b.to_owned() {
        println!("they match")
    }
}

(playground)

Note that there is no PartialEq implementation between Foo and Bar. This generates the following warning:

warning: redundant clone
  --> src/main.rs:24:14
   |
24 |     if f == b.to_owned() {
   |              ^^^^^^^^^^^ help: remove this
   |
   = note: `#[warn(clippy::redundant_clone)]` on by default
note: this value is dropped without further use
  --> src/main.rs:24:13
   |
24 |     if f == b.to_owned() {
   |             ^
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone

warning: 1 warning emitted

But applying the suggestion causes this error

error[E0308]: mismatched types
  --> src/main.rs:24:13
   |
24 |     if f == b {
   |             ^ expected struct `Foo`, found struct `Bar`

error: aborting due to previous error

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

(playground)

Clippy version: 0.0.212

[flip1995]

I don't see this as a bug in redundant_clone. The to_owned method is redundant, since Bar does not need to be cloned to be used.

Instead the to_owned method is used to convert a type in this example. For this, From<Bar> for Foo should be implemented.

I think this is a constructed example, that is not realistic in real code.

[ebroto]

Yep I agree the code is not ideal, I ran into this when testing edge cases of cmp_owned when working in #4874.

I opened the issue because the suggestion causes a compilation error and because I understood that the temporary is actually being used in the comparison.

But maybe it's not worth the effort because it's unlikely that someone writes this? In fact having this linted by redundant_clone could be a hint that this should be changed, even though the suggestion is not that explicit.

[ebroto]

To be clear, I assumed that if it results in a compilation error then it's a false positive, but maybe this is unlikely to happen

[flip1995]

I assumed that if it results in a compilation error then it's a false positive

Normally it would be, but in this case to_owned is misused for type conversion. So I'm not sure if anything has to be changed in the redundant_clone lint. But I would leave this open, if someone else somehow experiences this.