required trait implementation for cmp is incorrect

[gftea]

I tried this code:

    #[derive(Eq)]
    struct Person {
        id: u32,
        name: String,
        height: u32,
    }

    impl PartialOrd for Person {
        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
            Some(self.cmp(other))
        }
    }

     // I intentionaly comment out this code
    // impl Ord for Person {
    //     fn cmp(&self, other: &Self) -> Ordering {
    //         self.height.cmp(&other.height)
    //     }
    // }

    impl PartialEq for Person {
        fn eq(&self, other: &Self) -> bool {
            self.height == other.height
        }
    }

I expected to see this happen:

indicate missing implementation for trait Ord

Instead, this happened:

it indicates missing trait implementation of iterator.

rror[E0599]: the method `cmp` exists for reference `&Person`, but its trait bounds were not satisfied
  --> examples/cmp_eq_ord.rs:39:23
   |
31 |     struct Person {
   |     -------------
   |     |
   |     doesn't satisfy `Person: Iterator`
   |     doesn't satisfy `Person: Ord`
...
39 |             Some(self.cmp(other))
   |                       ^^^ method cannot be called on `&Person` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `Person: Ord`
           which is required by `&Person: Ord`
           `&Person: Iterator`
           which is required by `&mut &Person: Iterator`
           `Person: Iterator`
           which is required by `&mut Person: Iterator`
note: the following trait must be implemented
  --> /home/gftea/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:67:1
   |
67 | pub trait Iterator {
   | ^^^^^^^^^^^^^^^^^^
help: consider annotating `Person` with `#[derive(Eq, Ord, PartialEq, PartialOrd)]`
   |
31 |     #[derive(Eq, Ord, PartialEq, PartialOrd)]
   |

Meta

rustc --version --verbose:

rustc 1.67.0 (fc594f156 2023-01-24)
binary: rustc
commit-hash: fc594f15669680fa70d255faec3ca3fb507c3405
commit-date: 2023-01-24
host: x86_64-unknown-linux-gnu
release: 1.67.0
LLVM version: 15.0.6

Backtrace

<backtrace>

[quaternic]

Here's a variant of the same issue:

//#[derive(PartialOrd,PartialEq)]
struct Foo;

fn foo(a: Foo, b: Foo) {
    if a.partial_cmp(&b).is_some() {}
}

If the derive is uncommented, it compiles, but this errors with:

error[E0599]: `Foo` is not an iterator
 --> <source>:5:10
  |
2 | struct Foo;
  | ----------
  | |
  | method `partial_cmp` not found for this struct
  | doesn't satisfy `Foo: Iterator`
...
5 |     if a.partial_cmp(&b).is_some() {}
  |          ^^^^^^^^^^^ `Foo` is not an iterator
  |
  = note: the following trait bounds were not satisfied:
          `Foo: Iterator`
          which is required by `&mut Foo: Iterator`
note: the trait `Iterator` must be implemented
 --> /rustc/87e1447aadaa2899ff6ccabe1fa669eb50fb60a1/library/core/src/iter/traits/iterator.rs:75:1
  = help: items from traits can only be used if the trait is implemented and in scope
  = note: the following trait defines an item `partial_cmp`, perhaps you need to implement it:
          candidate #1: `Iterator`

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0599`.
Compiler returned: 1

Notably that doesn't mention PartialOrd at all, even though it would seem far more likely that someone calling partial_cmp is expecting PartialOrd::partial_cmp than Iterator::partial_cmp. Previously it did: rustc 1.42.0 still listed both traits as candidates.