title: Why is this Swift switch statement with two enums not exhaustive?
body: <p>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:</p>
  
  <pre><code>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..&lt;4 {
      for j in 0..&lt;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")
          }
      }
  }
  </code></pre>
  
  <p>Which prints out:</p>
  
  <pre><code>one, _
  one, _
  one, _
  one, _
  _, one
  two, _
  two, _
  two, _
  _, one
  _, two
  three, three
  three, four
  _, one
  _, two
  four, three
  four, four
  </code></pre>
  
  <p>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.</p>
  
  <p>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?</p>