TAIT: empty match on TAIT confuses typeck

[Nadrieril]

I tried this code (playground):

#![feature(type_alias_impl_trait)]
#![allow(unconditional_recursion)]

#[derive(Copy, Clone)]
enum Void {}

mod match_wildcard {
    type X = impl Copy; // ok
    fn empty_opaque(x: super::Void) -> X {
        match empty_opaque(x) {
            _ => {}
        }
        x
    }
}

mod empty_match {
    type X = impl Copy;
    //~^ ERROR unconstrained opaque type
    fn empty_opaque(x: super::Void) -> X {
        match empty_opaque(x) {}
        x
    }
}

Somehow in the second case we think that X is unconstrained even though it doesn't seem to contain more or less type information than the first case. Note also that this does not error if I use RPIT instead.

[oli-obk]

I think in the second example mir building doesn't generate code for the trailing expression because it's statically known as dead code. But I thought we were keeping around the typeck types nowadays, and typeck should be the same for both functions

[Nadrieril]

I don't think that's it, same error if I put the match in a branch (updated playground link with more variations):

type X = impl Copy;
//~^ ERROR unconstrained opaque type
fn empty_opaque(x: super::Void) -> X {
    if false {
        match empty_opaque(x) {}
        //~^ ERROR non-empty
    }
    x
}

[Nadrieril]

In fact this doesn't need an empty type at all:

type X = impl Copy;
//~^ ERROR unconstrained opaque type
fn empty_opaque() -> X {
    if false {
        match empty_opaque() {}
        //~^ ERROR non-empty
    }
    0u8
}

[compiler-errors]

I think we're generating bogus MIR or THIR because of that empty match --

fn empty_opaque() -> {type error} {
    let mut _0: {type error};

    bb0: {
        unreachable;
    }
}

Are you sure the bug doesn't exist on the THIR/MIR building side, @Nadrieril?

(hacked -Zunpretty=mir to dump the mir_built instead of instance_mir)

[Nadrieril]

Oh I'm sure of nothing 😄 I just assumed an unreachable in a if false branch would not affect anything else

[compiler-errors]

So:

rust/compiler/rustc_mir_build/src/build/mod.rs

Lines 58 to 60 in e6e931d

	if let Err(e) = tcx.check_match(def) {
	return construct_error(tcx, def, e);
	}

If there's a match error, we end up constructing a failure MIR body. This will prevent us from inferring the opaque later on. This is because nothing in HIR actually constrains the TAIT either. edit: that last sentence was a lie

Let me see if I can cook up a quick fix.