Incorrect inference of match expression result

[0x7CFE]

commit 5aba5a756a19a54d5c4edd51d8055db36182688b
Merge: a4431e830 56e3fbe58
Author: bors[bot] <26634292+bors[bot]@users.noreply.github.com>
Date:   Thu Feb 6 23:00:07 2020 +0000

    Merge #3042

The following snippet from wasmtime repo is mistakenly inferred as ! instead of FrameUnwindKind:

Update: aside of local discussion about known issue with local imports, this issue boils down to

let x = match 0 {
    _ => y,
};

…where x is inferred as ! when it probably should be {unknown}.

[lnicola]

The following works:

enum E {
    A,
    B,
}

fn foo(e: E) -> E {
    let x = match e {
        E::A => 1,
        _ => {
            return E::B;
        }
    };
    E::A
}

Does "go to definition" work for CallConv and FrameUnwindKind?

[0x7CFE]

Update: if I move corresponding use imports to the topmost scope it all starts working as expected:

[0x7CFE]

Does "go to definition" work for CallConv and FrameUnwindKind?

Nope, it wasn't working before the import change. As you may see, on the first screenshot CallConv and FrameUnwindKind are not highlighted as types.

[lnicola]

Yeah, use in local scopes doesn't work too great: #1165.

[0x7CFE]

Yeah, use in local scopes doesn't work too great: #1165.

Oh, indeed. And @matklad's reply there states that probably this will not be resolved anytime soon. That's unfortunate :(

[lnicola]

Still, you could argue that the inference should work better. I think the issue is that FrameUnwindKind can't be resolved. The type of match should probably be {unknown}, not !.

It's probably a bug in #1945, but I don't really understand the code 🐱.

[0x7CFE]

The type of match should probably be {unknown}, not !.

Agree. It's very strange that type is inferred that way given that analyzer clearly does not have enough information.

[lnicola]

let x = match 0 {
    _ => y,
};

x gets inferred as !.

[lnicola]

Maybe you can update the first post with my example above, since it's simpler?

[flodiebold]

#3114 fixes the reduced case where there are no match arms that diverge, but if there's a diverging match arm (like in the original case), we'll still fall back to !. Interestingly, rustc seems to fall back to () in at least some of these cases. This will require some further thought 🤔

[0x7CFE]

@flodiebold, as for the () issue recent reddit post discusses similar behavior.

[lnicola]

Type inference works fine now for:

enum E {
    A,
    B,
}

fn foo(e: E) -> E {
    let x = match e {
        E::A => 1,
        _ => {
            return E::B;
        }
    };
    E::A
}

I think this can be closed.