Handle divergence in type inference for blocks

[lnicola]

Fixes #1944.

The infer_basics test is failing, not sure what to do about it.

[flodiebold]

I think we also need to consider cases like some_function(return) or if some_condition { return; } else { return; }, and check what rustc does with them -- I think it considers them diverging as well, though I don't know whether it gives them type !. (These may seem useless, but some_function(unimplemented!()) or if some_condition { panic!() } else { return; } aren't...)

[flodiebold]

The infer_basics change is probably fine, though as mentioned I'd still want to check what rustc does for this.

[lnicola]

I'm not sure how to check. rustc says that the function returns (), but that's the declared type, while our test shows the type of the block that makes up the function's body.

[lnicola]

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=dfb2c41af9af50a8d6ba4c74bdfc9288

I think it's also ! in rustc?

[flodiebold]

Yeah, but in a more roundabout way: If the block diverges, rustc does not treat the missing tail expression as (). And if there are no returns/breaks in the block and no provided type, that means it gets typed as !.

In general, I think we do need to track divergence separately from the type of the expression, similar to rustc, because e.g. for let x = SomeStruct { field: unimplemented!() } we wouldn't want to say x: !. None the less, I think this change goes in the right direction for that, so let's merge it 🙂

bors r+

[bors]

Build succeeded

• continuous-integration/travis-ci/push

[lnicola]

e.g. for let x = SomeStruct { field: unimplemented!() } we wouldn't want to say x: !

That actually works because the code is only checking for ! on statements, not bindings.

[flodiebold]

Well yeah, it still works, but we should actually be checking for divergence inside expressions. For example this type checks:

fn test() -> i128 {
    foo(unimplemented!());
}

fn bar() -> i128 {
    Struct { field: unimplemented!() };
}

So we do need to recognize that Struct { field: unimplemented!() } diverges, but we don't want to give it type !. So we need to track divergence separately from the type.