Merge pull request swiftlang#34969 from DougGregor/swift_get_jobflags

[Concurrency] Traffic in underlying C type rather than JobFlags.

Author: DougGregor

include/swift/AST/DiagnosticsParse.def

@@ -1222,6 +1222,8 @@ ERROR(super_in_closure_with_capture,none,
 NOTE(super_in_closure_with_capture_here,none,
      "'self' explicitly captured here", ())
 
+ERROR(try_before_await,none, "'await' must precede 'try'", ())
+
 // Tuples and parenthesized expressions
 ERROR(expected_expr_in_expr_list,none,
       "expected expression in list of expressions", ())

include/swift/Runtime/Concurrency.h

@@ -175,8 +175,7 @@ bool swift_task_removeStatusRecord(AsyncTask *task,
                                    TaskStatusRecord *record);
 
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-JobFlags
-swift_task_getJobFlags(AsyncTask* task);
+size_t swift_task_getJobFlags(AsyncTask* task);
 
 /// This should have the same representation as an enum like this:
 ///    enum NearestTaskDeadline {

lib/Parse/ParseExpr.cpp

@@ -436,6 +436,13 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
       : parseExprUnary(message, isExprBasic);
 
   if (hadTry && !sub.hasCodeCompletion() && !sub.isNull()) {
+    // "await" must precede "try".
+    if (auto await = dyn_cast<AwaitExpr>(sub.get())) {
+      diagnose(await->getLoc(), diag::try_before_await)
+        .fixItRemove(await->getLoc())
+        .fixItInsert(tryLoc, "await ");
+    }
+
     ElementContext.setCreateSyntax(SyntaxKind::TryExpr);
     switch (trySuffix ? trySuffix->getKind() : tok::NUM_TOKENS) {
     case tok::exclaim_postfix:

lib/Sema/TypeCheckEffects.cpp

@@ -985,8 +985,9 @@ class Context {
   }
 
   static Context forTopLevelCode(TopLevelCodeDecl *D) {
-    // Top-level code implicitly handles errors and 'async' calls.
-    return Context(/*handlesErrors=*/true, /*handlesAsync=*/true, None);
+    // Top-level code implicitly handles errors.
+    // TODO: Eventually, it will handle async as well.
+    return Context(/*handlesErrors=*/true, /*handlesAsync=*/false, None);
   }
 
   static Context forFunction(AbstractFunctionDecl *D) {

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -89,7 +89,7 @@ public func withUnsafeContinuation<T>(
 public func withUnsafeThrowingContinuation<T>(
   _ fn: (UnsafeThrowingContinuation<T>) -> Void
 ) async throws -> T {
-  return try await Builtin.withUnsafeThrowingContinuation {
+  return await try Builtin.withUnsafeThrowingContinuation {
     fn(UnsafeThrowingContinuation<T>($0))
   }
-}
+}

stdlib/public/Concurrency/Task.cpp

@@ -352,6 +352,6 @@ void swift::swift_task_run(AsyncTask *taskToRun) {
   taskToRun->run(ExecutorRef::generic());
 }
 
-JobFlags swift::swift_task_getJobFlags(AsyncTask *task) {
-  return task->Flags;
+size_t swift::swift_task_getJobFlags(AsyncTask *task) {
+  return task->Flags.getOpaqueValue();
 }

test/ClangImporter/objc_async.swift

@@ -8,7 +8,7 @@ import ObjCConcurrency
 func testSlowServer(slowServer: SlowServer) async throws {
   let _: Int = await slowServer.doSomethingSlow("mail")
   let _: Bool = await slowServer.checkAvailability()
-  let _: String = try await slowServer.findAnswer()
+  let _: String = await try slowServer.findAnswer()
   let _: String = await try slowServer.findAnswerFailingly()
   let _: Void = await slowServer.doSomethingFun("jump")
   let _: (Int) -> Void = slowServer.completionHandler

test/Concurrency/async_tasks.swift

@@ -54,11 +54,11 @@ func test_unsafeContinuations() async {
 }
 
 func test_unsafeThrowingContinuations() async {
-  let _: String = try await Task.withUnsafeThrowingContinuation { continuation in
+  let _: String = await try Task.withUnsafeThrowingContinuation { continuation in
     continuation.resume(returning: "")
   }
 
-  let _: String = try await Task.withUnsafeThrowingContinuation { continuation in
+  let _: String = await try Task.withUnsafeThrowingContinuation { continuation in
     continuation.resume(throwing: MyError())
   }
 

test/IRGen/async.swift

@@ -19,7 +19,7 @@ public func task_future_wait(_ task: __owned SomeClass) async throws -> Int
 // CHECK: tail call swiftcc void @swift_task_future_wait(
 public func testThis(_ task: __owned SomeClass) async {
   do {
-    let _ = try await task_future_wait(task)
+    let _ = await try task_future_wait(task)
   } catch _ {
     print("error")
   }

test/SILGen/async_builtins.swift

@@ -93,7 +93,7 @@ public func usesWithUnsafeContinuation() async {
 
 // CHECK-LABEL: sil [ossa] @$s4test34usesWithUnsafeThrowingContinuationyyYKF : $@convention(thin) @async () -> @error Error {
 public func usesWithUnsafeThrowingContinuation() async throws {
-  let _: Int = try await Builtin.withUnsafeThrowingContinuation { c in }
+  let _: Int = await try Builtin.withUnsafeThrowingContinuation { c in }
 
   // CHECK: [[FN:%.*]] = function_ref @$s4test34usesWithUnsafeThrowingContinuationyyYKFyBcXEfU_ : $@convention(thin) (Builtin.RawUnsafeContinuation) -> ()
   // CHECK: [[TMP:%.*]] = convert_function [[FN]] : $@convention(thin) (Builtin.RawUnsafeContinuation) -> () to $@convention(thin) @noescape (Builtin.RawUnsafeContinuation) -> ()
@@ -117,4 +117,4 @@ public func usesWithUnsafeThrowingContinuation() async throws {
 // because it has captures and was formed by a partial_apply.
 public func usesWithUnsafeContinuationCaptures(fn: (Builtin.RawUnsafeContinuation) -> ()) async throws {
   let _: Int = await Builtin.withUnsafeContinuation { c in fn(c) }
-}
+}