Missing dead code warning

[eernstg]

Consider the following program:

sealed class A {}
class B1 extends A {}
class B2 extends A {}
class C {}

int f(A a) => switch (a) {
  B1() => 1,
  B2() => 2,
  C() => 3,
};

I just learned that the above switch expression does not give rise to a dead code warning. It is guaranteed that when the scrutinee a has static type A, the run-time type of a will match B1() or B2(). This implies that the C() case is dead code, in spite of the fact that there could be an object whose run-time type is a subtype of A and also a subtype of C (class D implements B1, C {} could be declared in any library).

A small experiment shows that the exhaustiveness is recognized already: Comment out C() => 3: No exhaustiveness error is reported for the switch. This implies that all additional cases will be dead.

Could we emit a dead code warning in this case? It seems sound and useful.

Note, though, that the ordering is significant: If the C() => 3 case is moved up to an earlier position then it is not impossible that it could be matched, and hence it isn't dead code.

[bwilkerson]

@johnniwinther

Sorry, I didn't see that you'd changed the area until after I'd changed it back. My understanding is that the dead code warning in this case would come from the exhaustiveness checker.

I agree that if we can determine that the code can't be reached that we should flag it, so I'm thinking that this is an implementation request.