Under JDK-8367530, the "switch is not exhaustive" errors are being improved. The approach seems to work well if there is a single case missing, but if there are multiple cases missing, the errors may still be a bit too generic. As an example:
```
$ cat /tmp/Test.java
package test;
public class Test {
    public static class Case1 {
        private int test(Root r) {
            return switch (r) {
                case Root(R1 _, _, _) -> 0;
                case Root(R2 _, R1 _, _) -> 0;
                case Root(R2 _, R2 _, R1 _) -> 0;
                case Root(R2 _, R2(R1 _, R1 _), R2(R1 _, R1 _)) -> 0;
                case Root(R2 _, R2(R1 _, R1 _), R2(R1 _, R2 _)) -> 0;
                case Root(R2 _, R2(R1 _, R1 _), R2(R2 _, R1 _)) -> 0;
                case Root(R2 _, R2(R1 _, R1 _), R2(R2 _, R2 _)) -> 0;
                case Root(R2 _, R2(R1 _, R2 _), R2(R1 _, R1 _)) -> 0;
                case Root(R2 _, R2(R1 _, R2 _), R2(R1 _, R2 _)) -> 0;
// case Root(R2 _, R2(R1 _, R2 _), R2(R2 _, R1 _)) -> 0;
                case Root(R2 _, R2(R1 _, R2 _), R2(R2 _, R2 _)) -> 0;
                case Root(R2 _, R2(R2 _, R1 _), R2(R1 _, R1 _)) -> 0;
                case Root(R2 _, R2(R2 _, R1 _), R2(R1 _, R2 _)) -> 0;
                case Root(R2 _, R2(R2 _, R1 _), R2(R2 _, R1 _)) -> 0;
                case Root(R2 _, R2(R2 _, R1 _), R2(R2 _, R2 _)) -> 0;
                case Root(R2 _, R2(R2 _, R2 _), R2(R1 _, R1 _)) -> 0;
                case Root(R2 _, R2(R2 _, R2 _), R2(R1 _, R2 _)) -> 0;
                case Root(R2 _, R2(R2 _, R2 _), R2(R2 _, R1 _)) -> 0;
// case Root(R2 _, R2(R2 _, R2 _), R2(R2 _, R2 _)) -> 0;
            };
        }
        sealed interface Base {}
        record R1() implements Base {}
        record R2(Base b1, Base b2) implements Base {}
        record Root(Base b1, Base b2, Base b3) {}
    }

    public static class Case2 {
        private int test(Triple p) {
            return switch (p) {
                case Triple(B _, _, _) -> 0;
                case Triple(_, A _, _) -> 0;
                case Triple(_, _, A _) -> 0;
// case Triple(A _, C(Nested _, NestedBaseA _), _) -> 0;
                case Triple(A _, C(Nested _, NestedBaseB _), C(Nested _, NestedBaseA _)) -> 0;
                case Triple(A _, C(Nested _, NestedBaseB _), C(Nested _, NestedBaseB _)) -> 0;
                case Triple(A _, C(Nested _, NestedBaseB _), C(Nested _, NestedBaseC _)) -> 0;
                case Triple(A _, C(Nested _, NestedBaseC _), C(Nested _, NestedBaseA _)) -> 0;
                case Triple(A _, C(Nested _, NestedBaseC _), C(Nested _, NestedBaseB _)) -> 0;
// case Path(A _, C(Nested _, NestedBaseC _), C(Nested _, NestedBaseC _)) -> 0;
            };
        }
        record Triple(Base c1, Base c2, Base c3) {}
        sealed interface Base permits A, B {}
        record A(boolean key) implements Base {
        }
        sealed interface B extends Base {}
        record C(Nested n, NestedBase b) implements B {}
        record Nested() {}
        sealed interface NestedBase {}
        record NestedBaseA() implements NestedBase {}
        record NestedBaseB() implements NestedBase {}
        record NestedBaseC() implements NestedBase {}
    }
}
$ ./build/linux-x86_64-server-release/jdk/bin/javac /tmp/Test.java
/tmp/Test.java:5: error: the switch expression does not cover all possible input values
            return switch (r) {
                   ^
  missing patterns:
      Root(R2 _,R2(Base _,R2 _),R2(R2 _,Base _))
/tmp/Test.java:35: error: the switch expression does not cover all possible input values
            return switch (p) {
                   ^
  missing patterns:
      Triple(A _,C(Nested _,NestedBaseA _),C _)
      Triple(A _,C(Nested _,NestedBaseC _),C _)
2 errors
```

Note the reported errors are more generic than the commented-out cases. It would be nice if the errors could be improved in cases like this.