op_ref false positive with deref coercions when comparing

[euclio]

Perhaps related to #2042, but it seemed different enough to open a new issue.

With the following code: https://play.rust-lang.org/?gist=35d367db95cd56394d0bb9a05247b94c&version=nightly

fn main() {
    let a: &str = "abc";
    let b: String = "abc".to_owned();
    println!("{}", a > &b);
}

Clippy complains that the reference should be removed, but removing the reference causes the code to stop compiling.

[oli-obk]

Clippy on playpen is down. If memory serves right, isn't it also suggesting to deref the other side?

[euclio]

The error message reported by clippy is:

┌ euclio@apollo ~/repos/op_ref_test (git:master)
└╌╌┄┄ ❯❯ cargo +nightly clippy
   Compiling op_ref_test v0.1.0 (file:///Users/anrussell/repos/op_ref_test)
warning: taken reference of right operand
 --> src/main.rs:6:20
  |
6 |     println!("{}", a > &b);
  |                    ^^^^--
  |                        |
  |                        help: use the right value directly: `b`
  |
  = note: #[warn(op_ref)] on by default
  = help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.191/index.html#op_ref

    Finished dev [unoptimized + debuginfo] target(s) in 1.37 secs

[oli-obk]

We need to suggest a deref on the lhs here, too.

From the playpen link, he is actually comparing &str and String. In this case, deref on the lhs doesn't work. I think this is a false positive since gt requires a reference.

fn main() {
    let a: &str = "abc";
    let b: String = "abc".to_owned();
    println!("{}", a > &b); // works
    println!("{}", *a > b); // doesn't work
}

   Compiling playground v0.0.1 (file:///playground)
error[E0308]: mismatched types
 --> src/main.rs:5:25
  |
5 |     println!("{}", *a > b); // doesn't work
  |                         ^ expected str, found struct `std::string::String`
  |
  = note: expected type `str`
             found type `std::string::String`

[oli-obk]

Dereferencing both sides works. We can probably figure this out by checking for autoref coercions

I didn't know that was possible but what benefit does *a > *b have over a > &b?
Also this seems to be a regression of #1665.

[oli-obk]

The advantage is one less temporary variable (the comparison operator internally takes a reference to its arguments).

[jsgf]

I just ran into this with https://play.rust-lang.org/?version=stable&mode=debug&edition=2015&gist=890234c7ce6d7ccde1d036ae41d782d4

pub fn false_clippy_op_ref<T: Ord + PartialOrd>(array: &[T], val: &T, idx: usize) -> bool {
    &array[idx] < val
}