Explode on uncaught error thrown in main

This patch has two desirable effects for the price of one.
 1. An uncaught error thrown from main will now explode
 2. Move us off of using runAsyncAndBlock

The issue with runAsyncAndBlock is that it blocks the main thread
outright. UI and the main actor need to run on the main thread or bad
things happen, so blocking the main thread results in a bad day for
them.

Instead, we're using CFRunLoopRun to run the core-foundation run loop on
the main thread, or, dispatch_main if CFRunLoopRun isn't available.
The issue with just using dispatch_main is that it doesn't actually
guarantee that it will run the tasks on the main thread either, just
that it clears the main queue. We don't want to require everything that
uses concurrency to have to include CoreFoundation either, but dispatch
is already required, which supplies dispatch_main, which just empties
out the main queue.

Author: etcwilde

include/swift/Runtime/Concurrency.h

@@ -349,6 +349,11 @@ void swift_continuation_throwingResumeWithError(/* +1 */ SwiftError *error,
 extern "C" SWIFT_CC(swift)
 void swift_continuation_logFailedCheck(const char *message);
 
+/// Drain the queue
+/// If the binary links CoreFoundation, uses CFRunLoopRun
+/// Otherwise it uses dispatchMain.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_asyncMainDrainQueue();
 }
 
 #endif

lib/Sema/TypeCheckAttr.cpp

@@ -1936,7 +1936,7 @@ synthesizeMainBody(AbstractFunctionDecl *fn, void *arg) {
   Expr *returnedExpr;
 
   if (mainFunction->hasAsync()) {
-    // Pass main into _runAsyncMain(_ asyncFunc: () async -> ())
+    // Pass main into _runAsyncMain(_ asyncFunc: () async throws -> ())
     // Resulting $main looks like:
     // $main() { _runAsyncMain(main) }
     auto *concurrencyModule = context.getLoadedModule(context.Id_Concurrency);

stdlib/public/Concurrency/Task.cpp

@@ -22,6 +22,10 @@
 #include "TaskPrivate.h"
 #include "AsyncCall.h"
 
+#include <dispatch/dispatch.h>
+
+#include <dlfcn.h>
+
 using namespace swift;
 using FutureFragment = AsyncTask::FutureFragment;
 using GroupFragment = AsyncTask::GroupFragment;
@@ -528,3 +532,12 @@ SWIFT_CC(swift)
 void swift::swift_continuation_logFailedCheck(const char *message) {
   swift_reportError(0, message);
 }
+
+void swift::swift_task_asyncMainDrainQueue() {
+  auto runLoop =
+      reinterpret_cast<void (*)(void)>(dlsym(RTLD_SELF, "CFRunLoopRun"));
+  if (runLoop)
+    runLoop();
+  else
+    dispatch_main();
+}

stdlib/public/Concurrency/Task.swift

@@ -323,8 +323,20 @@ func isTaskCancelled(_ task: Builtin.NativeObject) -> Bool
 @_silgen_name("swift_task_runAndBlockThread")
 public func runAsyncAndBlock(_ asyncFun: @escaping () async -> ())
 
-@_silgen_name("swift_task_runAndBlockThread")
-public func _runAsyncMain(_ asyncFun: () async throws -> ())
+@_silgen_name("swift_task_asyncMainDrainQueue")
+public func _asyncMainDrainQueue() -> Never
+
+public func _runAsyncMain(_ asyncFun: @escaping () async throws -> ()) {
+  let _ = Task.runDetached {
+    do {
+      await try asyncFun()
+      exit(EXIT_SUCCESS)
+    } catch {
+      _errorInMain(error)
+    }
+  }
+  _asyncMainDrainQueue()
+}
 
 @_silgen_name("swift_task_future_wait")
 func _taskFutureWait(

stdlib/public/SwiftShims/_SwiftConcurrency.h

@@ -25,6 +25,10 @@ typedef struct _SwiftContext {
   struct _SwiftContext *parentContext;
 } _SwiftContext;
 
+void exit(int);
+
+#define EXIT_SUCCESS 0
+
 #ifdef __cplusplus
 } // extern "C"
 } // namespace swift

test/Concurrency/async_main.swift

@@ -21,7 +21,7 @@ func asyncFunc() async { }
 // CHECK-AST-NEXT:    (return_stmt implicit
 // CHECK-AST-NEXT:      (call_expr implicit type='()'
 // CHECK-AST-NEXT:        (declref_expr implicit
-// CHECK-AST-SAME:             type='(() async throws -> ()) -> ()'
+// CHECK-AST-SAME:             type='(@escaping () async throws -> ()) -> ()'
 // CHECK-AST-SAME:             decl=_Concurrency.(file)._runAsyncMain
 // CHECK-AST-SAME:             function_ref=single
 // CHECK-AST-NEXT:        (paren_expr implicit type='(() async throws -> ())'