Merge pull request swiftlang#35214 from DougGregor/await-try-to-try-await

[Concurrency] `await try` -> `try await`

Author: DougGregor

include/swift/AST/DiagnosticsParse.def

@@ -1223,7 +1223,7 @@ 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'", ())
+WARNING(await_before_try,none, "'try' must precede 'await'", ())
 WARNING(warn_await_keyword,none, 
       "future versions of Swift reserve the word 'await'; "
       "if this name is unavoidable, use backticks to escape it", ())

lib/Parse/ParseExpr.cpp

@@ -405,6 +405,13 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
       ParserResult<Expr> sub =
         parseExprSequenceElement(diag::expected_expr_after_await, isExprBasic);
       if (!sub.hasCodeCompletion() && !sub.isNull()) {
+        if (auto anyTry = dyn_cast<AnyTryExpr>(sub.get())) {
+          // "try" must precede "await".
+          diagnose(awaitLoc, diag::await_before_try)
+            .fixItRemove(awaitLoc)
+            .fixItInsert(anyTry->getSubExpr()->getStartLoc(), "await ");
+        }
+
         ElementContext.setCreateSyntax(SyntaxKind::AwaitExpr);
         sub = makeParserResult(new (Context) AwaitExpr(awaitLoc, sub.get()));
       }
@@ -448,13 +455,6 @@ 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:

stdlib/public/Concurrency/PartialAsyncTask.swift

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

stdlib/public/Concurrency/Task.swift

@@ -122,7 +122,7 @@ extension Task {
     /// and throwing a specific error or using `checkCancellation` the error
     /// thrown out of the task will be re-thrown here.
     public func get() async throws -> Success {
-      return await try _taskFutureGetThrowing(task)
+      return try await _taskFutureGetThrowing(task)
     }
 
     /// Attempt to cancel the task.

stdlib/public/Concurrency/TaskGroup.swift

@@ -86,7 +86,7 @@ extension Task {
         //   (although there should be none left by that time)
         defer { group.cancelAll() }
 
-        let result = await try body(&group)
+        let result = try await body(&group)
 
         /// Drain all remaining tasks by awaiting on them;
         /// Their failures are ignored;
@@ -98,7 +98,7 @@ extension Task {
     // Enqueue the resulting job.
     _enqueueJobGlobal(Builtin.convertTaskToJob(groupTask))
 
-    return await try Handle<BodyResult>(task: groupTask).get()
+    return try await Handle<BodyResult>(task: groupTask).get()
   }
 
   /// A task group serves as storage for dynamically started tasks.
@@ -122,7 +122,7 @@ extension Task {
     /// Add a child task to the group.
     ///
     /// ### Error handling
-    /// Operations are allowed to `throw`, in which case the `await try next()`
+    /// Operations are allowed to `throw`, in which case the `try await next()`
     /// invocation corresponding to the failed task will re-throw the given task.
     ///
     /// The `add` function will never (re-)throw errors from the `operation`.
@@ -155,13 +155,13 @@ extension Task {
     ///
     /// Await on a single completion:
     ///
-    ///     if let first = await try group.next() {
+    ///     if let first = try await group.next() {
     ///        return first
     ///     }
     ///
     /// Wait and collect all group child task completions:
     ///
-    ///     while let first = await try group.next() {
+    ///     while let first = try await group.next() {
     ///        collected += value
     ///     }
     ///     return collected
@@ -253,7 +253,7 @@ extension Task.Group {
     //
     // Failures of tasks are ignored.
     while !self.isEmpty {
-      _ = await try? self.next()
+      _ = try? await self.next()
       // TODO: Should a failure cause a cancellation of the task group?
       //       This looks very much like supervision trees,
       //       where one may have various decisions depending on use cases...

test/ClangImporter/objc_async.swift

@@ -8,16 +8,16 @@ import ObjCConcurrency
 func testSlowServer(slowServer: SlowServer) async throws {
   let _: Int = await slowServer.doSomethingSlow("mail")
   let _: Bool = await slowServer.checkAvailability()
-  let _: String = await try slowServer.findAnswer()
-  let _: String = await try slowServer.findAnswerFailingly()
+  let _: String = try await slowServer.findAnswer()
+  let _: String = try await slowServer.findAnswerFailingly()
 
-  let (aOpt, b) = await try slowServer.findQAndA()
+  let (aOpt, b) = try await slowServer.findQAndA()
   if let a = aOpt { // make sure aOpt is optional
     print(a)
   }
   let _: String = b // make sure b is non-optional
 
-  let _: String = await try slowServer.findAnswer()
+  let _: String = try await slowServer.findAnswer()
 
   let _: Void = await slowServer.doSomethingFun("jump")
   let _: (Int) -> Void = slowServer.completionHandler
@@ -29,8 +29,8 @@ func testSlowServer(slowServer: SlowServer) async throws {
   let _: Int = slowServer.doSomethingConflicted("thinking")
   // expected-error@-1{{call is 'async' but is not marked with 'await'}}{{16-16=await }}
 
-  let _: String? = await try slowServer.fortune()
-  let _: Int = await try slowServer.magicNumber(withSeed: 42)
+  let _: String? = try await slowServer.fortune()
+  let _: Int = try await slowServer.magicNumber(withSeed: 42)
 
   await slowServer.serverRestart("localhost")
   await slowServer.serverRestart("localhost", atPriority: 0.8)

test/Concurrency/Runtime/actor_counters.swift

@@ -70,7 +70,7 @@ func runTest(numCounters: Int, numWorkers: Int, numIterations: Int) async {
 
   // Wait until all of the workers have finished.
   for worker in workers {
-    await try! worker.get()
+    try! await worker.get()
   }
 
   // Clear out the scratch buffer.

test/Concurrency/Runtime/async_taskgroup_add_handle_completion.swift

@@ -20,7 +20,7 @@ func completeSlowly(n: Int) async -> Int {
 
 /// Tasks complete AFTER they are next() polled.
 func test_sum_nextOnPending() async {
-  let sum = await try! Task.withGroup(resultType: Int.self) { (group) async -> Int in
+  let sum = try! await Task.withGroup(resultType: Int.self) { (group) async -> Int in
     let firstHandle = await group.add {
       let res = await completeSlowly(n: 1)
       return res
@@ -34,16 +34,16 @@ func test_sum_nextOnPending() async {
       return res
     }
 
-    let first = await try! firstHandle.get()
+    let first = try! await firstHandle.get()
     print("firstHandle.get(): \(first)")
-    let second = await try! secondHandle.get()
+    let second = try! await secondHandle.get()
     print("secondHandle.get(): \(second)")
-    let third = await try! thirdHandle.get()
+    let third = try! await thirdHandle.get()
     print("thirdHandle.get(): \(third)")
 
     var sum = 0
     print("before group.next(), sum: \(sum)")
-    while let n = await try! group.next() {
+    while let n = try! await group.next() {
       assert(n <= 3, "Unexpected value: \(n)! Expected <= 3")
       print("next: \(n)")
       sum += n

test/Concurrency/Runtime/async_taskgroup_is_empty.swift

@@ -17,7 +17,7 @@ func asyncEcho(_ value: Int) async -> Int {
 }
 
 func test_taskGroup_isEmpty() async {
-  _ = await try! Task.withGroup(resultType: Int.self) { (group) async -> Int in
+  _ = try! await Task.withGroup(resultType: Int.self) { (group) async -> Int in
     // CHECK: before add: isEmpty=true
     print("before add: isEmpty=\(group.isEmpty)")
 
@@ -30,7 +30,7 @@ func test_taskGroup_isEmpty() async {
     print("while add running, outside: isEmpty=\(group.isEmpty)")
 
     // CHECK: next: 1
-    while let value = await try! group.next() {
+    while let value = try! await group.next() {
       print("next: \(value)")
     }
 

test/Concurrency/Runtime/async_taskgroup_next_not_invoked_cancelAll.swift

@@ -9,7 +9,7 @@ import Dispatch
 func test_skipCallingNext_butInvokeCancelAll() async {
   let numbers = [1, 1]
 
-  let result = await try! Task.withGroup(resultType: Int.self) { (group) async -> Int in
+  let result = try! await Task.withGroup(resultType: Int.self) { (group) async -> Int in
     for n in numbers {
       print("group.add { \(n) }")
       await group.add { () async -> Int in