Rewrite sugared optional tuple patterns

Author: CodaFi

lib/Sema/TypeCheckSwitchStmt.cpp

@@ -134,12 +134,17 @@ namespace {
       }
 
     public:
-      explicit Space(Type T)
+      explicit
+      Space(Type T)
         : Kind(SpaceKind::Type), TypeAndVal(T, false), Head(Identifier()),
           Spaces({}){}
       explicit Space(Type T, Identifier H, bool downgrade, SmallVectorImpl<Space> &SP)
         : Kind(SpaceKind::Constructor), TypeAndVal(T, downgrade), Head(H),
           Spaces(SP.begin(), SP.end()) {}
+      explicit Space(Type T, Identifier H, bool downgrade,
+                     const std::forward_list<Space> &SP)
+        : Kind(SpaceKind::Constructor), TypeAndVal(T, downgrade), Head(H),
+          Spaces(SP.begin(), SP.end()) {}
       explicit Space(SmallVectorImpl<Space> &SP)
         : Kind(SpaceKind::Disjunct), TypeAndVal(Type(), false),
           Head(Identifier()), Spaces(SP.begin(), SP.end()) {}
@@ -1267,6 +1272,14 @@ namespace {
       }
       case PatternKind::OptionalSome: {
         auto *OSP = cast<OptionalSomePattern>(item);
+        auto subSpace = projectPattern(TC, OSP->getSubPattern(), sawDowngradablePattern);
+        // To match patterns like (_, _, ...)?, we must rewrite the underlying
+        // tuple pattern to .some(_, _, ...) first.
+        if (subSpace.getKind() == SpaceKind::Constructor
+            && subSpace.getHead().empty()) {
+          return Space(item->getType(), TC.Context.getIdentifier("some"),
+                       /*canDowngrade*/false, subSpace.getSpaces());
+        }
         SmallVector<Space, 1> payload = {
           projectPattern(TC, OSP->getSubPattern(), sawDowngradablePattern)
         };

test/Sema/exhaustive_switch.swift

@@ -6,6 +6,19 @@ func foo(a: Int?, b: Int?) -> Int {
   case (_, .none): return 2
   case (.some(_), .some(_)): return 3
   }
+    
+  switch (a, b) {
+  case (.none, _): return 1
+  case (_, .none): return 2
+  case (_?, _?): return 3
+  }
+  
+  switch Optional<(Int?, Int?)>.some((a, b)) {
+  case .none: return 1
+  case let (_, x?)?: return x
+  case let (x?, _)?: return x
+  case (.none, .none)?: return 0
+  }
 }
 
 func bar(a: Bool, b: Bool) -> Int {
@@ -47,6 +60,15 @@ func foo() {
   case (_, .B(_)):
     ()
   }
+  
+  switch (Foo.A(1), Optional<(Int, Int)>.some((0, 0))) {
+  case (.A(_), _):
+    break
+  case (.B(_), (let q, _)?):
+    print(q)
+  case (.B(_), nil):
+    break
+  }
 }
 
 class C {}