Suggests T: Iterator bound for cmp, when Ord was intended #120186

ryanavella · 2024-01-21T05:00:22Z

Code

fn f<T>(a: T, b: T) -> std::cmp::Ordering {
    a.cmp(&b)
}

Current output

error[E0599]: `T` is not an iterator
 --> main.rs:2:7
  |
1 | fn f<T>(a: T, b: T) -> std::cmp::Ordering {
  |      - method `cmp` not found for this type parameter
2 |     a.cmp(&b)
  |       ^^^ `T` is not an iterator
  |
  = note: the following trait bounds were not satisfied:
          `T: Iterator`
          which is required by `&mut T: Iterator`
help: consider restricting the type parameter to satisfy the trait bound
  |
1 | fn f<T>(a: T, b: T) -> std::cmp::Ordering where T: Iterator {
  |                                           +++++++++++++++++

error: aborting due to 1 previous error

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

Desired output

Something that also includes a suggestion of T: Ord. (see further down for examples that do provide this suggestion)

Rationale and extra context

It is my impression that <T as Ord>::cmp is encountered just as often as <T as Iterator>::cmp, if not more often, so I was expecting a suggestion to add a T: Ord bound as well.

Other cases

No response

Rust Version

$ rustc --version --verbose
rustc 1.77.0-nightly (88189a71e 2024-01-19)
binary: rustc
commit-hash: 88189a71e4e4376eea82ac61db6a539612eb200a
commit-date: 2024-01-19
host: x86_64-unknown-freebsd
release: 1.77.0-nightly
LLVM version: 17.0.6

Anything else?

If instead the code is tweaked slightly to the following:

fn f<T>(a: T, b: T) -> std::cmp::Ordering {
    <_>::cmp(&a, &b)
}

It produces a much more helpful diagnostic:

error[E0034]: multiple applicable items in scope
    --> main.rs:2:10
     |
2    |     <_>::cmp(&a, &b)
     |          ^^^ multiple `cmp` found
     |
note: candidate #1 is defined in the trait `Ord`
    --> ~/.rustup/toolchains/nightly-x86_64-unknown-freebsd/lib/rustlib/src/rust/library/core/src/cmp.rs:814:5
     |
814  |     fn cmp(&self, other: &Self) -> Ordering;
     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: candidate #2 is defined in the trait `Iterator`
    --> ~/.rustup/toolchains/nightly-x86_64-unknown-freebsd/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:3692:5
     |
3692 | /     fn cmp<I>(self, other: I) -> Ordering
3693 | |     where
3694 | |         I: IntoIterator<Item = Self::Item>,
3695 | |         Self::Item: Ord,
3696 | |         Self: Sized,
     | |____________________^
help: use fully-qualified syntax to disambiguate
     |
2    |     Iterator::cmp(&a, &b)
     |     ~~~~~~~~~~
2    |     Ord::cmp(&a, &b)
     |     ~~~~~

error: aborting due to 1 previous error

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

Similarly helpful diagnostics can be seen if we tweak it to <T>::cmp or <&T>::cmp.

The text was updated successfully, but these errors were encountered:

ryanavella · 2024-01-22T16:58:15Z

I found another variation that differs by only 1 byte, and produces much better diagnostics:

//   add a reference
//         v
fn f<T>(a: &T, b: T) -> std::cmp::Ordering {
    a.cmp(&b)
}

Output

error[E0599]: the method `cmp` exists for reference `&T`, but its trait bounds were not satisfied
--> src/lib.rs:2:7
|
2 |     a.cmp(&b)
|       ^^^ method cannot be called on `&T` due to unsatisfied trait bounds
|
= note: the following trait bounds were not satisfied:
        `T: Ord`
        which is required by `&T: Ord`
        `&T: Iterator`
        which is required by `&mut &T: Iterator`
        `T: Iterator`
        which is required by `&mut T: Iterator`
help: consider restricting the type parameters to satisfy the trait bounds
|
1 | fn f<T>(a: &T, b: T) -> std::cmp::Ordering where T: Iterator, T: Ord {
|                                            +++++++++++++++++++++++++

For more information about this error, try `rustc --explain E0599`.
error: could not compile `playground` (lib) due to previous error

Similar output can be seen by instead rewriting the body as (&a as &T).cmp(&b).

If I didn't know any better, I think the main problem here is that bound suggestions are not considering methods that would become available after autoref?

quaternic · 2024-01-22T19:41:43Z

Might be a duplicate of #108428

ryanavella · 2024-01-22T21:52:55Z

Might be a duplicate of #108428

Ah, I missed this while searching the issue tracker. My diagnostic looks very similar to your follow-up comment in that thread, though I'm not sure if it is exactly related to @gftea's original report. They at least get a helpful T: Ord suggestion, whereas you and I don't even get that.

I'll defer to a rustc dev to decide whether this is a duplicate or entirely separate issue.

When encountering ```rust fn f<T>(a: T, b: T) -> std::cmp::Ordering { a.cmp(&b) //~ ERROR E0599 } ``` output ``` error[E0599]: no method named `cmp` found for type parameter `T` in the current scope --> $DIR/method-on-unbounded-type-param.rs:2:7 | LL | fn f<T>(a: T, b: T) -> std::cmp::Ordering { | - method `cmp` not found for this type parameter LL | a.cmp(&b) | ^^^ method cannot be called on `T` due to unsatisfied trait bounds | = help: items from traits can only be used if the type parameter is bounded by the trait help: the following traits define an item `cmp`, perhaps you need to restrict type parameter `T` with one of them: | LL | fn f<T: Ord>(a: T, b: T) -> std::cmp::Ordering { | +++++ LL | fn f<T: Iterator>(a: T, b: T) -> std::cmp::Ordering { | ++++++++++ ``` Fix rust-lang#120186.

…param, r=nnethercote Account for unbounded type param receiver in suggestions When encountering ```rust fn f<T>(a: T, b: T) -> std::cmp::Ordering { a.cmp(&b) //~ ERROR E0599 } ``` output ``` error[E0599]: no method named `cmp` found for type parameter `T` in the current scope --> $DIR/method-on-unbounded-type-param.rs:2:7 | LL | fn f<T>(a: T, b: T) -> std::cmp::Ordering { | - method `cmp` not found for this type parameter LL | a.cmp(&b) | ^^^ method cannot be called on `T` due to unsatisfied trait bounds | = help: items from traits can only be used if the type parameter is bounded by the trait help: the following traits define an item `cmp`, perhaps you need to restrict type parameter `T` with one of them: | LL | fn f<T: Ord>(a: T, b: T) -> std::cmp::Ordering { | +++++ LL | fn f<T: Iterator>(a: T, b: T) -> std::cmp::Ordering { | ++++++++++ ``` Fix rust-lang#120186.

Rollup merge of rust-lang#120396 - estebank:method-on-unbounded-type-param, r=nnethercote Account for unbounded type param receiver in suggestions When encountering ```rust fn f<T>(a: T, b: T) -> std::cmp::Ordering { a.cmp(&b) //~ ERROR E0599 } ``` output ``` error[E0599]: no method named `cmp` found for type parameter `T` in the current scope --> $DIR/method-on-unbounded-type-param.rs:2:7 | LL | fn f<T>(a: T, b: T) -> std::cmp::Ordering { | - method `cmp` not found for this type parameter LL | a.cmp(&b) | ^^^ method cannot be called on `T` due to unsatisfied trait bounds | = help: items from traits can only be used if the type parameter is bounded by the trait help: the following traits define an item `cmp`, perhaps you need to restrict type parameter `T` with one of them: | LL | fn f<T: Ord>(a: T, b: T) -> std::cmp::Ordering { | +++++ LL | fn f<T: Iterator>(a: T, b: T) -> std::cmp::Ordering { | ++++++++++ ``` Fix rust-lang#120186.

Rudxain · 2024-04-10T06:49:05Z

   Compiling playground v0.0.1 (/playground)
error[E0599]: the method `max` exists for type parameter `T`, but its trait bounds were not satisfied
 --> src/lib.rs:2:15
  |
1 | fn abs<T: core::ops::Neg<Output = T> + Clone>(x: T) -> T {
  |        - method `max` not found for this type parameter
2 |     x.clone().max(-x)
  |               ^^^ method cannot be called on `T` due to unsatisfied trait bounds
  |
  = note: the following trait bounds were not satisfied:
          `T: Ord`
          which is required by `&T: Ord`
          `T: Ord`
          which is required by `&mut T: Ord`
          `T: Iterator`
          which is required by `&mut T: Iterator`
help: consider restricting the type parameters to satisfy the trait bounds
  |
1 | fn abs<T: core::ops::Neg<Output = T> + Clone>(x: T) -> T where T: Iterator, T: Ord {
  |                                                          +++++++++++++++++++++++++

For more information about this error, try `rustc --explain E0599`.
error: could not compile `playground` (lib) due to 1 previous error

Following the compiler suggestion:

   Compiling playground v0.0.1 (/playground)
error[E0034]: multiple applicable items in scope
    --> src/lib.rs:6:15
     |
6    |     x.clone().max(-x)
     |               ^^^ multiple `max` found
     |
note: candidate #1 is defined in the trait `Ord`
    --> /playground/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/cmp.rs:830:5
     |
830  | /     fn max(self, other: Self) -> Self
831  | |     where
832  | |         Self: Sized,
     | |____________________^
note: candidate #2 is defined in the trait `Iterator`
    --> /playground/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:3208:5
     |
3208 | /     fn max(self) -> Option<Self::Item>
3209 | |     where
3210 | |         Self: Sized,
3211 | |         Self::Item: Ord,
     | |________________________^
help: disambiguate the method for candidate #1
     |
6    |     Ord::max(x.clone(), -x)
     |
help: disambiguate the method for candidate #2
     |
6    |     Iterator::max(x.clone(), -x)
     |

For more information about this error, try `rustc --explain E0034`.
error: could not compile `playground` (lib) due to 1 previous error

Simply removing T: Iterator, solves the error

ryanavella added A-diagnostics Area: Messages for errors, warnings, and lints T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Jan 21, 2024

estebank mentioned this issue Jan 26, 2024

Account for unbounded type param receiver in suggestions #120396

Merged

zjp-CN mentioned this issue Feb 2, 2024

rustc should first suggest adding a trait bound on generic impl block when inherent method name bound by that trait collides with methods from unintended traits in scope #120568

Open

bors closed this as completed in 20b1c2a Feb 7, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Suggests T: Iterator bound for cmp, when Ord was intended #120186

Suggests T: Iterator bound for cmp, when Ord was intended #120186

ryanavella commented Jan 21, 2024 •

edited

ryanavella commented Jan 22, 2024

quaternic commented Jan 22, 2024

ryanavella commented Jan 22, 2024

Rudxain commented Apr 10, 2024

Suggests T: Iterator bound for cmp, when Ord was intended #120186

Suggests T: Iterator bound for cmp, when Ord was intended #120186

Comments

ryanavella commented Jan 21, 2024 • edited

Code

Current output

Desired output

Rationale and extra context

Other cases

Rust Version

Anything else?

ryanavella commented Jan 22, 2024

quaternic commented Jan 22, 2024

ryanavella commented Jan 22, 2024

Rudxain commented Apr 10, 2024

ryanavella commented Jan 21, 2024 •

edited