False positive for derive_partial_eq_without_eq when using PhantomData

[Herschel]

Summary

A struct with PhantomData will trigger the derive_partial_eq_without_eq even though it derives both Eq, PartialEq.

clippy 0.1.63 (9257f5a 2022-05-21)

Lint Name

derive_partial_eq_without_eq

Reproducer

I tried this code:

#[derive(Eq, PartialEq)]
struct Index<T>(std::marker::PhantomData<T>);

I saw this happen:

warning: you are deriving `PartialEq` and can implement `Eq`
 --> src\main.rs:1:14
  |
1 | #[derive(Eq, PartialEq)]
  |              ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
  |
  = note: `#[warn(clippy::derive_partial_eq_without_eq)]` on by default
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#derive_partial_eq_without_eq

I expected to see this happen:
No warning.

Version

rustc 1.63.0-nightly (9257f5aad 2022-05-21)
binary: rustc
commit-hash: 9257f5aad02b65665a6e23e5b92938548302e129
commit-date: 2022-05-21
host: x86_64-pc-windows-msvc
release: 1.63.0-nightly
LLVM version: 14.0.4

Additional Labels

No response

[Herschel]

Playground link: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=96d52b13153e88afc7a0dd683c04f7d4

[izik1]

I was about to post an almost identical issue, so instead I'll just affirm this happens, and that I found a slightly smaller repro (dependencies wise, not bytes wise):

#[derive(Eq, PartialEq)]
pub struct Outer<T>(Inner<T>);

struct Inner<T>(T);

impl<T> PartialEq for Inner<T> {
    fn eq(&self, other: &Self) -> bool {
        loop {}
    }
}

impl<T> Eq for Inner<T> {}

(note that the loop there causes a different warning- about empty loops and CPU cycles, completely true in this context- which could be removed by using panic! instead, but there's no clear guideline on which to choose in a situation like this so I went with my gut)

Note that the very similar:

#[derive(Eq, PartialEq)]
pub struct Outer<T>(Inner<T>);

struct Inner<T>(T);

impl<T> PartialEq for Inner<T> where T: PartialEq {
    fn eq(&self, other: &Self) -> bool {
        loop {}
    }
}

impl<T> Eq for Inner<T> where T: Eq {}

does not trigger this, so the issue seems to be with the more general bounds on Inner vs Outer

(immediately edited to mark the last snippet as rust)

[izik1]

Note that this is a very very fresh regression:
last "good" nightly (using git bisect terms):

rustc -Vv
rustc 1.63.0-nightly (e6a4afc3a 2022-05-20)
binary: rustc
commit-hash: e6a4afc3af2d2a53f91fc8a77bdfe94bea375b29
commit-date: 2022-05-20
host: x86_64-unknown-linux-gnu
release: 1.63.0-nightly
LLVM version: 14.0.4

Which means that the first "bad" nightly is:

rustc 1.63.0-nightly (9257f5aad 2022-05-21)
binary: rustc
commit-hash: 9257f5aad02b65665a6e23e5b92938548302e129
commit-date: 2022-05-21
host: x86_64-unknown-linux-gnu
release: 1.63.0-nightly
LLVM version: 14.0.4

[Bromeon]

Can confirm this, just hit the issue in a CI run.

I was first thinking Clippy had a bug with ordering #[derive(Eq, PartialEq)] as it suggests

help: consider deriving `Eq` as well: `PartialEq, Eq`.

However, changing to #[derive(PartialEq, Eq)] still caused the same issue.

[boydjohnson]

This bug got me recently, and I wanted to point out a small change can be made to @izik1 2nd example and make it trip up the bug.

#[derive(Debug, PartialEq, Eq)]
pub struct Foo<T: Debug> {
    bar: Bar<T>,
}

#[derive(Debug)]
pub enum Bar<T> {
    One(T),
    Two,
}

impl<T> PartialEq for Bar<T>
where
    T: PartialEq + Debug,
{
    fn eq(&self, other: &Bar<T>) -> bool {
        match (self, other) {
            (Self::One(_), Self::Two) => false,
            (Self::One(inner), Self::One(other_inner)) => inner.eq(other_inner),
            (Self::Two, Self::Two) => true,
            (Self::Two, Self::One(_)) => false,
        }
    }
}

impl<T: Debug + PartialEq> Eq for Bar<T> {}

Adding the second bound, and having it on the type parameter in the struct, will cause the clippy error.

warning: you are deriving `PartialEq` and can implement `Eq`
 --> src/main.rs:5:17
  |
5 | #[derive(Debug, PartialEq, Eq)]
  |                 ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
  |

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=0887f13a6f08bd514ab4070bdb837b8e

[WorldSEnder]

Also impacted by this when trying to conform to the new lint.

https://github.com/yewstack/yew/blob/e68060afa7421149f2d6aacace67c65c33e81fe5/packages/yew/src/virtual_dom/vtag.rs#L21-L23

[bstrie]

Same here, I suggest that this lint should be removed from clippy::all while this bug exists, as it's causing reams of false positives on my end.