Detect empty types in sub-patterns

[canndrew]

If I define the following types

enum Three {
    A,
    B,
    C,
}

enum Two {
    A,
    B,
}

enum One {
    A,
}

enum Zero {
}

I can pattern match on them like this

match three {
    Three::A => (),
    Three::B => (),
    Three::C => (),
};

match two {
    Two::A => (),
    Two::B => (),
};

match one {
    One::A => (),
};

match zero {
};

But if I put them inside something (not just a tuple), I can no longer match the empty case

match (three,) {
    (Three::A,) => (),
    (Three::B,) => (),
    (Three::C,) => (),
}

match (two,) {
    (Two::A,) => (),
    (Two::B,) => (),
};

match (one,) {
    (One::A,) => (),
};

match (zero,) {    // ERROR!
};

This is inconsistent.

[canndrew]

The main reason I want this is because it will allow people to match on enums while eliding variants that have been "deleted" using !. For example, people should be allowed to match on Result<T, !> with

match result {
    Ok(x) => x,
}

Currently, they have to do

match result {
    Ok(x) => x,
    Err(e) => e,
}

Which is confusing because it looks like they're matching on a Result<T, T>.

[canndrew]

Closing this as a dupe of #12609.