---

yaml
---
r: 347443
b: refs/heads/master
c: e0dfc43
h: refs/heads/master
i:
  347441: 2a44ca2
  347439: df24e56

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ee8837d2c674c27f19295a66f69e25dca65d051a
+refs/heads/master: e0dfc4372132f56ebcfee8a8c7eabb723d26e31c
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/Sema/TypeCheckSwitchStmt.cpp

@@ -1380,6 +1380,7 @@ namespace {
         }
       }
       case PatternKind::Typed:
+        llvm_unreachable("cannot appear in case patterns");
       case PatternKind::Expr:
         return Space();
       case PatternKind::Var: {
@@ -1428,6 +1429,8 @@ namespace {
                                        conArgSpace);
         }
         case PatternKind::Paren: {
+          // If we've got an extra level of parens, we need to flatten that into
+          // the enum payload.
           auto *PP = dyn_cast<ParenPattern>(SP);
           auto *SP = PP->getSemanticsProvidingPattern();
 
@@ -1448,6 +1451,12 @@ namespace {
             }
           } else if (SP->getKind() == PatternKind::Tuple) {
             Space argTupleSpace = projectPattern(TC, SP);
+            // Tuples are modeled as if they are enums with a single, nameless
+            // case, which means argTupleSpace will either be a Constructor or
+            // Empty space. If it's empty (i.e. it contributes nothing to the
+            // overall exhaustiveness), the entire enum case space is empty.
+            if (argTupleSpace.isEmpty())
+              return Space();
             assert(argTupleSpace.getKind() == SpaceKind::Constructor);
             conArgSpace.insert(conArgSpace.end(),
                                argTupleSpace.getSpaces().begin(),

trunk/test/Compatibility/exhaustive_switch.swift

@@ -1176,3 +1176,43 @@ extension Result where T == NoError {
     }
   }
 }
+
+enum SR10301<T,E> {
+  case value(T)
+  case error(E)
+}
+enum SR10301Error: Error {
+  case bad
+}
+
+func sr10301(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, SR10301Error.bad)): return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}
+
+func sr10301_is(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, is SR10301Error)): return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}
+
+func sr10301_as(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, let err as SR10301Error)):
+    _ = err
+    return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}

trunk/test/Sema/exhaustive_switch.swift

@@ -1135,3 +1135,43 @@ extension Result where T == NoError {
     }
   }
 }
+
+enum SR10301<T,E> {
+  case value(T)
+  case error(E)
+}
+enum SR10301Error: Error {
+  case bad
+}
+
+func sr10301(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, SR10301Error.bad)): return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}
+
+func sr10301_is(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, is SR10301Error)): return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}
+
+func sr10301_as(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, let err as SR10301Error)):
+    _ = err
+    return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}