Why is this Swift switch statement with two enums not exhaustive?

Question

I'm writing a bit of Swift code (Swift 3.1, Xcode 8.3.2) that switches on two enums. I believe I've written an exhaustive list of cases, but the compiler disagrees with me. My code is a bit complicated, with some associated values and such, so I boiled this down to as simple an example as I could in a playground, like so:

enum Test {
    case one
    case two
    case three
    case four
}

let allValues: [Test] = [.one, .two, .three, .four]
let test1 = Test.one
let test2 = Test.two

for i in 0..<4 {
    for j in 0..<4 {
        let test1 = allValues[i]
        let test2 = allValues[j]
        switch (test1, test2) {
        case (.one, _):
            print("one, _")
        case (_, .one):
            print("_, one")
        case (.two, _):
            print("two, _")
        case (_, .two):
            print("_, two")
        case (.three, .three):
            print("three, three")
        case (.three, .four):
            print("three, four")
        case (.four, .three):
            print("four, three")
        case (.four, .four):
            print("four, four")
//Won't compile with this commented out, but when enabled,
//we never print out "default"
//      default:
//          print("default")
        }
    }
}

Which prints out:

one, _
one, _
one, _
one, _
_, one
two, _
two, _
two, _
_, one
_, two
three, three
three, four
_, one
_, two
four, three
four, four

I would expect this to compile without the default clause, but the compiler gives "error: switch must be exhaustive, consider adding a default clause". If I add the default clause, it compiles and runs fine, but of course it never hits the default clause because all the previous case statements handle every variation of the two enums.

The default clause doesn't really harm anything, but I'd really like to understand why this switch isn't considered exhaustive by the compiler. Any ideas?

Answer 1

On Twitter, CodaFi pointed me towards the following, which indicates that it's a bug/shortcoming in the current version of the Swift compiler.

https://bugs.swift.org/browse/SR-483

https://bugs.swift.org/browse/SR-1313