[SILGen] Emit unreachable code diagnostic for single expression closures with implicit returns too (swiftlang#33604)

* [SILGen] Emit unreachable code diagnostics for single expression closures with implicit returns too

* [Test] Update diagnostic in test/SILGen/functions_uninhabited_param.swift

Author: theblixguy

lib/SILGen/SILGenStmt.cpp

@@ -292,7 +292,23 @@ void StmtEmitter::visitBraceStmt(BraceStmt *S) {
       // If this is an implicit statement or expression, just skip over it,
       // don't emit a diagnostic here.
       if (auto *S = ESD.dyn_cast<Stmt*>()) {
-        if (S->isImplicit()) continue;
+        // Return statement in a single-expression closure or function is
+        // implicit, but the result isn't. So, skip over return statements
+        // that are implicit and either have no results or the result is
+        // implicit. Otherwise, don't so we can emit unreachable code
+        // diagnostics.
+        if (S->isImplicit() && isa<ReturnStmt>(S)) {
+          auto returnStmt = cast<ReturnStmt>(S);
+          if (!returnStmt->hasResult()) {
+            continue;
+          }
+          if (returnStmt->getResult()->isImplicit()) {
+            continue;
+          }
+        }
+        if (S->isImplicit() && !isa<ReturnStmt>(S)) {
+          continue;
+        }
       } else if (auto *E = ESD.dyn_cast<Expr*>()) {
         // Optional chaining expressions are wrapped in a structure like.
         //

test/SILGen/functions_uninhabited_param.swift

@@ -9,9 +9,21 @@ func foo(baz: Never) -> Int { // expected-note {{'baz' is uninhabited, so this f
 
 func bar(baz: Never) -> Int {} // ok
 
+// SR-13432
+func map<T>(_ block: (Never) -> T) {}
+map { arg in // expected-note {{'arg' is uninhabited, so this function body can never be executed}}
+  5 // expected-warning {{will never be executed}}
+}
+
+map { arg in // expected-note {{'arg' is uninhabited, so this function body can never be executed}}
+  return 5 // expected-warning {{will never be executed}}
+}
+
 // We used to crash when emitting the closure below.
 enum E {
   static func f(_: E) {}
 }
 
 let _: (E.Type) -> (E) -> () = { s in { e in s.f(e) } }
+// expected-warning@-1 {{will never be executed}}
+// expected-note@-2 {{'e' is uninhabited, so this function body can never be executed}}