Diagnostics hint for const generics

[yoshuawuyts]

Current Behavior

Given the following code:

let mut combinations = (1..2).combinations();
assert_eq!(combinations.next(), None);

where Iterator::combinations is defined as:

fn combinations<const N: usize>(self) -> Combinations<Self, N>;

The following diagnostic is provided:

error[E0282]: type annotations needed
   --> src\lib.rs:144:32
    |
144 |         let mut combinations = (1..2).combinations();
    |                                ^^^^^^^^^^^^^^^^^^^^^
    |
    = note: unable to infer the value of a const parameter

Attempting a fix, and failing:

Naively I thought I could fix this by adding a turbofish, but that doesn't seem to help:

let mut combinations = (1..2).combinations::<[usize; 2]>();
assert_eq!(combinations.next(), None);

error[E0107]: wrong number of const arguments: expected 1, found 0
   --> src\lib.rs:144:39
    |
144 |         let mut combinations = (1..2).combinations::<[usize; 2]>();
    |                                       ^^^^^^^^^^^^ expected 1 const argument

error[E0107]: wrong number of type arguments: expected 0, found 1
   --> src\lib.rs:144:54
    |
144 |         let mut combinations = (1..2).combinations::<[usize; 2]>();
    |                                                      ^^^^^^^^^^ unexpected type argument

Expected behavior

Providing a hint on how to correctly define const generics would be immensely helpful. I'm sure I'll be able to figure out the syntax for this eventually (currently going through #78460 among others), but given we're set for a 1.51 stabilization of min_const_generics I suspect more people will be running into this soon.

Further Considerations

I was looking at how hints work for e.g. missing type params in collect, and noticed no hints are provided there either. It only explains what to do, not showing how to do it. For something that's notoriously tricky to learn that seems like it could benefit from hints as well.

let x = (1..5).collect();

error[E0282]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let x = (1..5).collect();
  |         ^ consider giving `x` a type

[yoshuawuyts]

Found the solution to my bug by the way. This did the trick:

let mut combinations = (1..2).combinations::<2>();
assert_eq!(combinations.next(), None);

I think it's fair to say that the diagnostics were not a great help here. And in particular providing the wrong param ([usize; 2]) yielded confusing diagnostics.

[lcnr]

error[E0282]: type annotations needed
--> src\lib.rs:144:32
|
144 | let mut combinations = (1..2).combinations();
| ^^^^^^^^^^^^^^^^^^^^^
|
= note: unable to infer the value of a const parameter

can you provide a full example for this? we should emit a suggestion to use a const arg here.
For example in https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=dd05e205a3af777ec388a4dba98e66e8

[yoshuawuyts]

Oh wow, the diagnostics for array_windows is heaps better! A full implementation of const Iterator::combinations can be found here: https://github.com/yoshuawuyts/const-combinations/blob/main/src/lib.rs

[estebank]

Current output:

error[E0284]: type annotations needed
  --> src/main.rs:11:35
   |
11 |     let mut combinations = (1..2).combinations();
   |                                   ^^^^^^^^^^^^ cannot infer the value of the const parameter `N` declared on the method `combinations`
   |
note: required by a const generic parameter in `T::combinations`
  --> src/main.rs:3:21
   |
 3 |     fn combinations<const N: usize>(self) -> Combinations<Self, N>;
   |                     ^^^^^^^^^^^^^^ required by this const generic parameter in `T::combinations`
help: consider specifying the generic argument
   |
11 |     let mut combinations = (1..2).combinations::<N>();
   |                                               +++++

error[E0284]: type annotations needed for `ArrayWindows<'_, i32, _>`
    --> src/main.rs:4:9
     |
   4 |     let mut combinations = [0; 2].array_windows();
     |         ^^^^^^^^^^^^^^^^          ------------- type must be known at this point
     |
note: required by a const generic parameter in `core::slice::<impl [T]>::array_windows`
    --> /playground/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/slice/mod.rs:1640:32
     |
1640 |     pub const fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N> {
     |                                ^^^^^^^^^^^^^^ required by this const generic parameter in `core::slice::<impl [T]>::array_windows`
help: consider giving `combinations` an explicit type, where the value of const parameter `N` is specified
     |
   4 |     let mut combinations: ArrayWindows<'_, _, N> = [0; 2].array_windows();
     |                         ++++++++++++++++++++++++

error[E0284]: type annotations needed for `ArrayWindows<'_, i32, _>`
 --> src/main.rs:4:9
  |
4 |     let mut combinations = [0; 2].array_windows();
  |         ^^^^^^^^^^^^^^^^
5 |     assert_eq!(combinations.next(), None);
  |                             ---- type must be known at this point
  |
  = note: required for `ArrayWindows<'_, i32, _>` to implement `Iterator`
help: consider giving `combinations` an explicit type, where the value of const parameter `N` is specified
  |
4 |     let mut combinations: ArrayWindows<'_, _, N> = [0; 2].array_windows();
  |                         ++++++++++++++++++++++++

error[E0284]: type annotations needed for `ArrayWindows<'_, i32, _>`
 --> src/main.rs:4:9
  |
4 |     let mut combinations = [0; 2].array_windows();
  |         ^^^^^^^^^^^^^^^^
5 |     assert_eq!(combinations.next(), None);
  |     ------------------------------------- type must be known at this point
  |
  = note: required for `[i32; _]` to implement `PartialEq`
  = note: 2 redundant requirements hidden
  = note: required for `Option<&[i32; _]>` to implement `PartialEq`
help: consider giving `combinations` an explicit type, where the value of const parameter `N` is specified
  |
4 |     let mut combinations: ArrayWindows<'_, _, N> = [0; 2].array_windows();
  |                         ++++++++++++++++++++++++

error[E0284]: type annotations needed for `ArrayWindows<'_, i32, _>`
   --> src/main.rs:4:9
    |
  4 |     let mut combinations = [0; 2].array_windows();
    |         ^^^^^^^^^^^^^^^^
  5 |     assert_eq!(combinations.next(), None);
    |     -------------------------------------
    |     |
    |     type must be known at this point
    |     required by a bound introduced by this call
    |
    = note: required for `[i32; _]` to implement `Debug`
    = note: 2 redundant requirements hidden
    = note: required for `Option<&[i32; _]>` to implement `Debug`
note: required by a bound in `core::panicking::assert_failed`
   --> /playground/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/panicking.rs:394:8
    |
387 | pub fn assert_failed<T, U>(
    |        ------------- required by a bound in this function
...
394 |     T: fmt::Debug + ?Sized,
    |        ^^^^^^^^^^ required by this bound in `assert_failed`
help: consider giving `combinations` an explicit type, where the value of const parameter `N` is specified
    |
  4 |     let mut combinations: ArrayWindows<'_, _, N> = [0; 2].array_windows();
    |                         ++++++++++++++++++++++++

error[E0283]: type annotations needed
    --> src/main.rs:6:9
     |
   6 |     let x = (1..5).collect();
     |         ^          ------- type must be known at this point
     |
     = note: cannot satisfy `_: FromIterator<i32>`
note: required by a bound in `collect`
    --> /playground/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/traits/iterator.rs:2015:19
     |
2015 |     fn collect<B: FromIterator<Self::Item>>(self) -> B
     |                   ^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Iterator::collect`
help: consider giving `x` an explicit type
     |
   6 |     let x: Vec<_> = (1..5).collect();
     |          ++++++++

We've gone from too terse to quite verbose 😅

The second case in particular has a huge fanout :-/