`impl Trait` and explicit const arguments

[varkor]

// run-pass

#![feature(const_generics)]
//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash

trait Usizer {
    fn m(self) -> usize;
}

fn f<const N: usize>(u: impl Usizer) -> usize {
    N + u.m()
}

struct Usizable;

impl Usizer for Usizable {
    fn m(self) -> usize {
        16
    }
}

fn main() {
    assert_eq!(f::<4usize>(Usizable), 20usize);
}

results in:

error[E0282]: type annotations needed
  --> bug.rs:23:16
   |
23 |     assert_eq!(f::<4usize>(Usizable), 20usize);
   |                ^^^^^^^^^^^ cannot infer type for `fn(Usizable) -> usize {f::<Usizable, _: usize>}`

[SephVelut]

This hits on my primary use for Const Generics; creating arbitrary sized arrays of data fed from a closure.

unsafe fn generate<T, const SIZE: usize>(mut next_val: impl FnMut() -> T) -> [T; SIZE] {
    let mut arr: [T; SIZE] = std::mem::uninitialized();

    for el in arr.iter_mut() {
        let mut data = next_val();

        std::ptr::write(el, data);
    }

    arr
}

Simple failing case:

fn foo<const SIZE: usize>(_: impl FnMut()) { }
fn main() {
    foo::<1usize>(||{});
}

error[E0282]: type annotations needed

[varkor]

We might want to use def_ids_for_value_path_segments in collect.rs, instead of duplicating some of that work there.

---

@SephVelut: thanks for the test case!

[varkor]

After #61570, the inference issue is fixed, but there's another error:

error[E0632]: cannot provide explicit type parameters when `impl Trait` is used in argument position.

due to: https://github.com/rust-lang/rust/blob/c5b39195f4a525a0ee29e39a114b6586c79a3c45/src/librustc_typeck/astconv.rs#L216
It uses infer_args (which is false if any generic args have been provided explicitly) as a proxy for "have any type arguments been provided explicitly". However, it is also true if const arguments have been provided, which is incorrect in this case.

[varkor]

We can change the check to:

let explicit = seg.args.iter().map(|args| args.args.iter()).flatten().any(|arg| {
    if let GenericArg::Type(_) = arg { true } else { false }
});

which removes the "cannot provide explicit type parameters" error, but I think the problem then is that the explicit const arg gets provided before the impl Trait implicit arg, whereas type arguments are always expected to come before const args. I'll look into this further tomorrow.

Edit: actually, the issue might be that we only infer IT arguments if infer_args, but this is now not always going to be true (if const args were provided). Therefore, we need to infer IT arguments as long as no type arguments were provided.

It might be better to split infer_args into an enum, so we can infer all, or just types (for IT).

[estebank]

Current output:

error[E0632]: cannot provide explicit type parameters when `impl Trait` is used in argument position.
  --> src/main.rs:23:16
   |
23 |     assert_eq!(f::<4usize>(Usizable), 20usize);
   |                ^^^^^^^^^^^

[varkor]

I'm tempted to say that this issue should be closed (at least after #65614), because the behaviour here is not specified by any RFC, and probably falls out of scope of at least the initial version of const generics.

Note that the suggested changes simply give the original inference issue.