`cannot infer type` when expression is logically negated in closure

[Isopod]

Hi! I’m pretty new to Rust, but I think I just encountered a bug in the compiler.

For some reason, Rust cannot “infer” the type of !a[i] in this code:

pub fn myfunction(x: &Vec<bool>) {
    let closure = |i, a: &Vec<bool>| { !a[i] };
    closure(0, x);
}

error[E0282]: type annotations needed
 --> main.rs:2:40
  |
2 |     let closure = |i, a: &Vec<bool>| { !a[i] };
  |                                        ^^^^^ cannot infer type

error: aborting due to previous error

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

But when you replace !a[i] with just a[i], then it compiles without error. So the error only occurs when there is a logical negation.

While narrowing this down, I also noticed that the error message appears to be a bit misleading: It looks like the compiler actually fails to infer the type of i, not !a[i], as the error goes away when I add a type annotation for i. Here is a more elaborate example, combining all of my three test cases:

pub fn myfunction(x: &Vec<bool>) {
    let one = |i, a: &Vec<bool>| {
        a[i]  // ok
    };
    let two = |i, a: &Vec<bool>| {
        !a[i] // cannot infer type
    };
    let three = |i: usize, a: &Vec<bool>| {
        !a[i] // ok
    };

    one(0, x);
    two(0, x);
    three(0, x);
}

fn main() {
}

Run it on Rust Playground

Reproduces on Stable, Beta and Nightly.

[chenyukang]

@rustbot claim

[chenyukang]

emm, this is because if i is without type, then a[i] will be a infer(_),
the closure one is return type is also _, so there is no error,
but ! with type _ is an error.
Need more dig for potential fix.

[Isopod]

It appears to happen with other unary operators as well, but never with binary operators:

pub fn bools(x: &Vec<bool>) {
    let binary = |i, a: &Vec<bool>| {
        a[i] && a[i+1] // ok
    };

    let unary = |i, a: &Vec<bool>| {
        !a[i] // cannot infer type
    };

    binary(0, x);
    unary(0, x);
}

pub fn ints(x: &Vec<isize>) {
    let binary = |i, a: &Vec<isize>| {
        a[i] + a[i+1] // ok
    };
    let unary = |i, a: &Vec<isize>| {
        -a[i] // cannot infer type
    };
    
    binary(0, x);
    unary(0, x);
}

Compiling playground v0.0.1 (/playground)
error[[E0282]](https://doc.rust-lang.org/stable/error-index.html#E0282): type annotations needed
 --> src/main.rs:7:9
  |
7 |         !a[i] // cannot infer type
  |         ^^^^^ cannot infer type

error[[E0282]](https://doc.rust-lang.org/stable/error-index.html#E0282): type annotations needed
  --> src/main.rs:20:9
   |
20 |         -a[i] // cannot infer type
   |         ^^^^^ cannot infer type

For more information about this error, try `rustc --explain E0282`.
error: could not compile `playground` due to 2 previous errors

Playground

[chenyukang]

I can not figure out a proper fix for this issue right now.
release for anyone want to have a try.
My branch FYI #107567