Type inference fails without intermediate variable

[nventuro]

Aim

I want to rely on type inference, but in some cases it only works if I have unnecessary intermediate variables.

Bug

In the following program, concise_but_does_not_compile errors out with Expression type is ambiguous. This is fixed in verbose_but_compiles, which introduces an intermediate variable a. I'm providing zero new type information, so this looks like a bug.

struct Wrapper<T> {
    _value: T,
}

impl<T> Wrapper<T> {
    fn new(value: T) -> Self {
        Self { _value: value }
    }

    fn unwrap(self) -> T {
        self._value
    }
}

trait MyTrait {
    fn new() -> Self;
}

struct MyType {

}

impl MyTrait for MyType {
    fn new() -> Self {
        MyType {}
    }
}

fn foo<T>() -> T where T: MyTrait {
    MyTrait::new()
}

fn verbose_but_compiles() -> MyType {
    let a = Wrapper::new(foo());
    a.unwrap()
}

fn concise_but_does_not_compile() -> MyType {
    Wrapper::new(foo()).unwrap()
}

fn main() {
    let _ = verbose_but_compiles();
    let _ = concise_but_does_not_compile();
}

[sirasistant]

Could be related to #4732 ?

[nventuro]

Yes, it is definitely the same thing. I didn't see that issue before, sorry. However this is likely a better example as the code sample does not rely on external libraies to trigger the bug.

[vezenovm]

Another workaround is to use turbofish now that Noir has the operator:

fn concise_but_does_not_compile() -> MyType {
    Wrapper::new(foo::<MyType>()).unwrap()
}

[vezenovm]

This is resolved if you want to try #4732 @sirasistant