SILGen: Diagnose unsupported shared case blocks for noncopyable switch subjects.

include/swift/AST/DiagnosticsSIL.def

@@ -1038,5 +1038,8 @@ NOTE(lifetime_outside_scope_use, none,
 NOTE(lifetime_outside_scope_escape, none,
      "this use causes the lifetime-dependent value to escape", ())
 
+ERROR(noncopyable_shared_case_block_unimplemented, none,
+      "matching a non-'Copyable' value using a case label that has multiple patterns is not implemented", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/SILGen/SILGenPattern.cpp

@@ -457,7 +457,8 @@ class PatternMatchEmission {
   void emitDestructiveCaseBlocks();
 
   JumpDest getSharedCaseBlockDest(CaseStmt *caseStmt);
-  void emitSharedCaseBlocks(llvm::function_ref<void(CaseStmt *)> bodyEmitter);
+  void emitSharedCaseBlocks(ValueOwnership ownership,
+                            llvm::function_ref<void(CaseStmt *)> bodyEmitter);
 
   void emitCaseBody(CaseStmt *caseBlock);
 
@@ -2790,8 +2791,13 @@ void PatternMatchEmission::emitDestructiveCaseBlocks() {
     // TODO: handle fallthroughs and multiple cases bindings
     // In those cases we'd need to forward bindings through the shared case
     // destination blocks.
-    assert(!stmt->hasFallthroughDest()
-           && stmt->getCaseLabelItems().size() == 1);
+    if (stmt->hasFallthroughDest()
+        || stmt->getCaseLabelItems().size() != 1) {
+      // This should already have been diagnosed as unsupported, so just emit
+      // an unreachable here.
+      SGF.B.createUnreachable(stmt);
+      continue;
+    }
 
     // Bind variables from the pattern.
     if (stmt->hasCaseBodyVariables()) {
@@ -2899,7 +2905,21 @@ emitAddressOnlyInitialization(VarDecl *dest, SILValue value) {
 
 /// Emit all the shared case statements.
 void PatternMatchEmission::emitSharedCaseBlocks(
+    ValueOwnership ownership,
     llvm::function_ref<void(CaseStmt *)> bodyEmitter) {
+  if (ownership >= ValueOwnership::Shared
+      && !SharedCases.empty()) {
+    SGF.SGM.diagnose(SharedCases.front().first,
+                     diag::noncopyable_shared_case_block_unimplemented);
+
+    for (auto &entry : SharedCases) {
+      SILBasicBlock *caseBB = entry.second.first;
+      SGF.B.setInsertionPoint(caseBB);
+      SGF.B.createUnreachable(entry.first);
+    }
+
+    return;
+  }
   for (auto &entry : SharedCases) {
     CaseStmt *caseBlock = entry.first;
     SILBasicBlock *caseBB = entry.second.first;
@@ -3742,7 +3762,7 @@ void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
   }
 
   // Then emit the case blocks shared by multiple pattern cases.
-  emission.emitSharedCaseBlocks(
+  emission.emitSharedCaseBlocks(ownership,
       [&](CaseStmt *caseStmt) { emission.emitCaseBody(caseStmt); });
 
   // Bookkeeping.
@@ -4015,7 +4035,8 @@ void SILGenFunction::emitCatchDispatch(DoCatchStmt *S, ManagedValue exn,
   stmtScope.pop();
 
   // Then emit the case blocks shared by multiple pattern cases.
-  emission.emitSharedCaseBlocks([&](CaseStmt *caseStmt) {
+  emission.emitSharedCaseBlocks(ValueOwnership::Default,
+  [&](CaseStmt *caseStmt) {
     emitStmt(caseStmt->getBody());
 
     // If we fell out of the catch clause, branch to the fallthrough dest.

test/SILGen/borrowing_switch_multiple_patterns.swift

@@ -0,0 +1,50 @@
+// RUN: %target-swift-emit-silgen -verify %s
+
+struct Inner: ~Copyable {}
+enum Outer: ~Copyable { case value(Inner, Int) }
+
+func borrow(_: borrowing Inner) {}
+func consume(_: consuming Inner) {}
+
+func foo(x: borrowing Outer) {
+    switch x {
+    case .value(let y, 0), // expected-error{{not implemented}}
+         .value(let y, _):
+        borrow(y)
+    }
+
+}
+
+func bar(x: borrowing Outer) {
+    switch x {
+    case .value(let y, 0):
+        borrow(y)
+        fallthrough
+
+    case .value(let y, _): // expected-error{{not implemented}}
+        borrow(y)
+    }
+
+}
+
+func zim(x: consuming Outer) {
+    switch consume x {
+    case .value(let y, 0), // expected-error{{not implemented}}
+         .value(let y, _):
+        consume(y)
+    }
+
+}
+
+func zang(x: consuming Outer) {
+    switch consume x {
+    case .value(let y, 0):
+        // should eventually test that this gets diagnosed as a double-consume
+        //consume(y)
+        fallthrough
+
+    case .value(let y, _): // expected-error{{not implemented}}
+        consume(y)
+    }
+
+}