Diagnose unreachable optional evaluation exprs

OptionalEvaluationExprs are always implicit and were
being let through SILGen's unreachable diagnostics
branch.  Decompose the structure to check to see if its
contents are not implicit expressions.  If that is the
case, then diagnose them.

Resolves SR-5763.

lib/SILGen/SILGenStmt.cpp

@@ -212,7 +212,22 @@ void StmtEmitter::visitBraceStmt(BraceStmt *S) {
       if (auto *S = ESD.dyn_cast<Stmt*>()) {
         if (S->isImplicit()) continue;
       } else if (auto *E = ESD.dyn_cast<Expr*>()) {
-        if (E->isImplicit()) continue;
+        // Optional chaining expressions are wrapped in a structure like.
+        //
+        // (optional_evaluation_expr implicit type='T?'
+        //   (call_expr type='T?'
+        //     (exprs...
+        //
+        // Walk through it to find out if the statement is actually implicit.
+        if (auto *OEE = dyn_cast<OptionalEvaluationExpr>(E)) {
+          if (auto *IIO = dyn_cast<InjectIntoOptionalExpr>(OEE->getSubExpr()))
+            if (IIO->getSubExpr()->isImplicit()) continue;
+          if (auto *C = dyn_cast<CallExpr>(OEE->getSubExpr()))
+            if (C->isImplicit()) continue;
+        } else if (E->isImplicit()) {
+          // Ignore all other implicit expressions.
+          continue;
+        }
       }
 
       if (StmtType != UnknownStmtType) {

test/SILGen/unreachable_code.swift

@@ -111,6 +111,15 @@ func testUnreachableCase5(a : Tree) {
   }
 }
 
+func testOptionalEvaluationBreak(a : Tree) {
+  class SR5763 { func foo() {} }
+  func createOptional() -> SR5763? { return SR5763() }
+  switch a {
+  case _:
+    break
+    createOptional()?.foo() // expected-warning {{code after 'break' will never be executed}}
+  }
+}
 
 func testUnreachableAfterThrow(e: Error) throws {
   throw e