Adding async-main support

This patch adds the async-main start-point for programs.
When a `static func main() async` is inserted into the main program, it
gets called through `_runAsyncMain` instead of calling directly. This
starts the program in an async context, which is good because then we
can do async stuff from there.

The following code

```
@main struct MyProgram {
  static func main() async {
    // async code
  }
}
```

is turned into

```
@main struct MyProgram {
  static func $main() {
    _runAsyncMain(main)
  }

  static func main() async {
    // async code
  }
}
```

_runAsyncMain code-gen's to the same thing as runAsyncAndBlock, which
emits a call to `swift_task_runAndBlockThread`.

Author: etcwilde

lib/Sema/TypeCheckAttr.cpp

@@ -1935,7 +1935,31 @@ synthesizeMainBody(AbstractFunctionDecl *fn, void *arg) {
 
   Expr *returnedExpr;
 
-  if (mainFunction->hasThrows()) {
+  if (mainFunction->hasAsync()) {
+    // Pass main into _runAsyncMain(_ asyncFunc: () async -> ())
+    // Resulting $main looks like:
+    // $main() { _runAsyncMain(main) }
+    auto *concurrencyModule = context.getLoadedModule(context.Id_Concurrency);
+    assert(concurrencyModule != nullptr && "Failed to find Concurrency module");
+
+    SmallVector<ValueDecl *, 1> decls;
+    concurrencyModule->lookupQualified(
+        concurrencyModule,
+        DeclNameRef(context.getIdentifier("_runAsyncMain")),
+        NL_QualifiedDefault | NL_IncludeUsableFromInline,
+        decls);
+    assert(!decls.empty() && "Failed to find _runAsyncMain");
+    FuncDecl *runner = cast<FuncDecl>(decls[0]);
+
+    auto asyncRunnerDeclRef = ConcreteDeclRef(runner, substitutionMap);
+
+    DeclRefExpr *funcExpr = new (context) DeclRefExpr(asyncRunnerDeclRef,
+                                                      DeclNameLoc(),
+                                                      /*implicit=*/true);
+    funcExpr->setType(runner->getInterfaceType());
+    auto *callExpr = CallExpr::createImplicit(context, funcExpr, memberRefExpr, {});
+    returnedExpr = callExpr;
+  } else if (mainFunction->hasThrows()) {
     auto *tryExpr = new (context) TryExpr(
         callExpr->getLoc(), callExpr, context.TheEmptyTupleType, /*implicit=*/true);
     returnedExpr = tryExpr;

stdlib/public/Concurrency/Task.swift

@@ -323,6 +323,9 @@ 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_future_wait")
 func _taskFutureWait(
   on task: Builtin.NativeObject

test/Concurrency/async_main.swift

@@ -0,0 +1,30 @@
+// RUN: %target-swift-frontend -dump-ast -enable-experimental-concurrency -parse-as-library %s | %FileCheck %s --check-prefix=CHECK-AST
+// REQUIRES: concurrency
+
+func asyncFunc() async { }
+
+@main struct MyProgram {
+  static func main() async {
+    await asyncFunc()
+  }
+}
+
+
+// CHECK-AST-LABEL: "main()" interface
+// CHECK-AST:       (await_expr type='()'
+// CHECK-AST-NEXT:    (call_expr type='()'
+// CHECK-AST-NEXT:       (declref_expr type='() async -> ()'
+// CHECK-AST-SAME:        decl=async_main.(file).asyncFunc()@
+
+// CHECK-AST-LABEL: (func_decl implicit "$main()" interface
+// CHECK-AST:       (brace_stmt
+// 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:             decl=_Concurrency.(file)._runAsyncMain
+// CHECK-AST-SAME:             function_ref=single
+// CHECK-AST-NEXT:        (paren_expr implicit type='(() async throws -> ())'
+// CHECK-AST-NEXT:          (function_conversion_expr implicit type='() async throws -> ()'
+// CHECK-AST-NEXT:          (dot_syntax_call_expr
+// CHECK-AST-NEXT:          (autoclosure_expr implicit type='(MyProgram.Type) -> () async -> ()'