Merge pull request #33807 from DougGregor/concurrency-nested-await-try

[Concurrency] Fix nested await/try parsing and effects checking.

Author: DougGregor

lib/Parse/ParseExpr.cpp

@@ -394,7 +394,8 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
 
   if (shouldParseExperimentalConcurrency() && Tok.isContextualKeyword("await")) {
     SourceLoc awaitLoc = consumeToken();
-    ParserResult<Expr> sub = parseExprUnary(message, isExprBasic);
+    ParserResult<Expr> sub =
+      parseExprSequenceElement(diag::expected_expr_after_await, isExprBasic);
     if (!sub.hasCodeCompletion() && !sub.isNull()) {
       ElementContext.setCreateSyntax(SyntaxKind::AwaitExpr);
       sub = makeParserResult(new (Context) AwaitExpr(awaitLoc, sub.get()));
@@ -428,7 +429,9 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
     }
   }
 
-  ParserResult<Expr> sub = parseExprUnary(message, isExprBasic);
+  ParserResult<Expr> sub = hadTry
+      ? parseExprSequenceElement(message, isExprBasic)
+      : parseExprUnary(message, isExprBasic);
 
   if (hadTry && !sub.hasCodeCompletion() && !sub.isNull()) {
     ElementContext.setCreateSyntax(SyntaxKind::TryExpr);

lib/Sema/TypeCheckEffects.cpp

@@ -1329,6 +1329,29 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     void mergeFrom(ContextFlag flag, ContextFlags other) {
       Bits |= (other.Bits & flag);
     }
+
+    void mergeFrom(ContextFlags flags, ContextFlags other) {
+      Bits |= (other.Bits & flags.Bits);
+    }
+
+    // All of the flags that can be set by throw checking.
+    static ContextFlags throwFlags() {
+      ContextFlags result;
+      result.set(IsTryCovered);
+      result.set(IsInTry);
+      result.set(HasAnyThrowSite);
+      result.set(HasTryThrowSite);
+      return result;
+    }
+
+    // All of the flags that can be set by async/await checking.
+    static ContextFlags asyncAwaitFlags() {
+      ContextFlags result;
+      result.set(IsAsyncCovered);
+      result.set(HasAnyAsyncSite);
+      result.set(HasAnyAwait);
+      return result;
+    }
   };
 
   ContextFlags Flags;
@@ -1408,6 +1431,10 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
       // body for the purposes of deciding whether a try contained
       // a throwing call.
       OldFlags.mergeFrom(ContextFlags::HasTryThrowSite, Self.Flags);
+
+      // "await" doesn't work this way; the "await" needs to be part of
+      // the autoclosure expression itself, and the autoclosure must be
+      // 'async'.
     }
 
     void preserveCoverageFromNonExhaustiveCatch() {
@@ -1417,16 +1444,21 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
 
     void preserveCoverageFromAwaitOperand() {
       OldFlags.mergeFrom(ContextFlags::HasAnyAwait, Self.Flags);
+      OldFlags.mergeFrom(ContextFlags::throwFlags(), Self.Flags);
+      OldMaxThrowingKind = std::max(OldMaxThrowingKind, Self.MaxThrowingKind);
     }
 
     void preserveCoverageFromTryOperand() {
       OldFlags.mergeFrom(ContextFlags::HasAnyThrowSite, Self.Flags);
+      OldFlags.mergeFrom(ContextFlags::asyncAwaitFlags(), Self.Flags);
       OldMaxThrowingKind = std::max(OldMaxThrowingKind, Self.MaxThrowingKind);
     }
 
     void preserveCoverageFromInterpolatedString() {
       OldFlags.mergeFrom(ContextFlags::HasAnyThrowSite, Self.Flags);
       OldFlags.mergeFrom(ContextFlags::HasTryThrowSite, Self.Flags);
+      OldFlags.mergeFrom(ContextFlags::HasAnyAsyncSite, Self.Flags);
+      OldFlags.mergeFrom(ContextFlags::HasAnyAwait, Self.Flags);
       OldMaxThrowingKind = std::max(OldMaxThrowingKind, Self.MaxThrowingKind);
     }
 

test/ClangImporter/objc_async.swift

@@ -1,16 +1,14 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-sil -I %S/Inputs/custom-modules -enable-experimental-concurrency %s -verify
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -I %S/Inputs/custom-modules -enable-experimental-concurrency %s -verify
 
 // REQUIRES: objc_interop
 import Foundation
 import ObjCConcurrency
 
-func testSlowServer(slowServer: SlowServer) async {
+func testSlowServer(slowServer: SlowServer) async throws {
   let _: Int = await slowServer.doSomethingSlow("mail")
   let _: Bool = await slowServer.checkAvailability()
-  let _: String = await slowServer.findAnswer() ?? "nope"
-  let _: String = await slowServer.findAnswerFailingly() ?? "nope"
-  // FIXME: expected-error@-2{{call can throw, but it is not marked with 'try'}}
-  // FIXME: expected-error@-2{{call can throw, but it is not marked with 'try'}}
+  let _: String = try await slowServer.findAnswer() ?? "nope"
+  let _: String = await try slowServer.findAnswerFailingly() ?? "nope"
   let _: Void = await slowServer.doSomethingFun("jump")
   let _: (Int) -> Void = slowServer.completionHandler
 }

test/expr/unary/async_await.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -typecheck -verify %s -enable-experimental-concurrency
+// RUN: %target-swift-frontend -typecheck -verify %s -enable-experimental-concurrency -verify-syntax-tree
 
 func test1(asyncfp : () async -> Int, fp : () -> Int) async {
   _ = await asyncfp()
@@ -72,3 +72,64 @@ func testClosure() {
 
   let _: () -> Int = closure2 // expected-error{{cannot convert value of type '() async -> Int' to specified type '() -> Int'}}
 }
+
+// Nesting async and await together
+func throwingAndAsync() async throws -> Int { return 0 }
+
+enum HomeworkError : Error {
+  case dogAteIt
+}
+
+func testThrowingAndAsync() async throws {
+  _ = await try throwingAndAsync()
+  _ = try await throwingAndAsync()
+  _ = await (try throwingAndAsync())
+  _ = try (await throwingAndAsync())
+
+  // Errors
+  _ = await throwingAndAsync() // expected-error{{call can throw but is not marked with 'try'}}
+  // expected-note@-1{{did you mean to use 'try'?}}
+  // expected-note@-2{{did you mean to handle error as optional value?}}
+  // expected-note@-3{{did you mean to disable error propagation?}}
+  _ = try throwingAndAsync() // expected-error{{call is 'async' but is not marked with 'await'}}
+}
+
+func testExhaustiveDoCatch() async {
+  do {
+    _ = await try throwingAndAsync()
+  } catch {
+  }
+
+  do {
+    _ = await try throwingAndAsync()
+    // expected-error@-1{{errors thrown from here are not handled because the enclosing catch is not exhaustive}}
+  } catch let e as HomeworkError {
+  }
+
+  // Ensure that we infer 'async' through an exhaustive do-catch.
+  let fn = {
+    do {
+      _ = await try throwingAndAsync()
+    } catch {
+    }
+  }
+
+  let _: Int = fn // expected-error{{cannot convert value of type '() async -> ()'}}
+
+  // Ensure that we infer 'async' through a non-exhaustive do-catch.
+  let fn2 = {
+    do {
+      _ = await try throwingAndAsync()
+    } catch let e as HomeworkError {
+    }
+  }
+
+  let _: Int = fn2 // expected-error{{cannot convert value of type '() async throws -> ()'}}
+}
+
+// String interpolation
+func testStringInterpolation() async throws {
+  _ = "Eventually produces \(getInt())" // expected-error{{call is 'async' but is not marked with 'await'}}
+  _ = "Eventually produces \(await getInt())"
+  _ = await "Eventually produces \(getInt())"
+}