[Concurrency] Improve await/try checking in 'async let' initializers.

Customize diagnostics when an 'await' is missing in an 'async let'
initializer. While here, fix the coverage checking so we also diagnose
a missing 'try'.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4087,6 +4087,9 @@ ERROR(async_call_without_await,none,
       "call is 'async' but is not marked with 'await'", ())
 ERROR(async_call_without_await_in_autoclosure,none,
       "call is 'async' in an autoclosure argument that is not marked with 'await'", ())
+ERROR(async_call_without_await_in_async_let,none,
+      "call is 'async' in an 'async let' initializer that is not marked "
+      "with 'await'", ())
 WARNING(no_async_in_await,none,
         "no calls to 'async' functions occur within 'await' expression", ())
 ERROR(async_call_in_illegal_context,none,

lib/Sema/TypeCheckEffects.cpp

@@ -1306,11 +1306,27 @@ class Context {
       highlight = apply->getSourceRange();
 
     auto diag = diag::async_call_without_await;
+
     // To produce a better error message, check if it is an autoclosure.
     // We do not use 'Context::isAutoClosure' b/c it gives conservative answers.
-    if (Function && llvm::isa_and_nonnull<AutoClosureExpr>(
-                                            Function->getAbstractClosureExpr()))
-      diag = diag::async_call_without_await_in_autoclosure;
+    if (Function) {
+      if (auto autoclosure = dyn_cast_or_null<AutoClosureExpr>(
+              Function->getAbstractClosureExpr())) {
+        switch (autoclosure->getThunkKind()) {
+        case AutoClosureExpr::Kind::None:
+          diag = diag::async_call_without_await_in_autoclosure;
+          break;
+
+        case AutoClosureExpr::Kind::AsyncLet:
+          diag = diag::async_call_without_await_in_async_let;
+          break;
+
+        case AutoClosureExpr::Kind::SingleCurryThunk:
+        case AutoClosureExpr::Kind::DoubleCurryThunk:
+          break;
+        }
+      }
+    }
 
     ctx.Diags.diagnose(node.getStartLoc(), diag)
         .fixItInsert(node.getStartLoc(), "await ")
@@ -1636,24 +1652,32 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
   ShouldRecurse_t checkAutoClosure(AutoClosureExpr *E) {
     ContextScope scope(*this, Context::forClosure(E));
     scope.enterSubFunction();
-    scope.resetCoverageForAutoclosureBody();
 
+    bool shouldPreserveCoverage = true;
     switch (E->getThunkKind()) {
     case AutoClosureExpr::Kind::DoubleCurryThunk:
     case AutoClosureExpr::Kind::SingleCurryThunk:
       // Curry thunks aren't actually a call to the asynchronous function.
       // Assume that async is covered in such contexts.
+      scope.resetCoverageForAutoclosureBody();
       Flags.set(ContextFlags::IsAsyncCovered);
       break;
 
     case AutoClosureExpr::Kind::None:
+      scope.resetCoverageForAutoclosureBody();
+      break;
+
     case AutoClosureExpr::Kind::AsyncLet:
+      scope.resetCoverage();
+      shouldPreserveCoverage = false;
       break;
     }
 
     E->getBody()->walk(*this);
 
-    scope.preserveCoverageFromAutoclosureBody();
+    if (shouldPreserveCoverage)
+      scope.preserveCoverageFromAutoclosureBody();
+
     return ShouldNotRecurse;
   }
 

test/expr/unary/async_await.swift

@@ -148,6 +148,9 @@ func validAsyncFunction() async throws {
 // Async let checking
 func mightThrow() throws { }
 
+func getIntUnsafely() throws -> Int { 0 }
+func getIntUnsafelyAsync() async throws -> Int { 0 }
+
 extension Error {
   var number: Int { 0 }
 }
@@ -162,6 +165,16 @@ func testAsyncLet() async throws {
   } catch let e where e.number == x { // expected-error{{async let 'x' cannot be referenced in a catch guard expression}}
   } catch {
   }
+
+  async let x1 = getIntUnsafely() // 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?}}
+
+  async let x2 = getInt() // expected-error{{call is 'async' in an 'async let' initializer that is not marked with 'await'}}
+
+  _ = await x1
+  _ = await x2
 }
 
 // expected-note@+2 4{{add 'async' to function 'testAsyncLetOutOfAsync()' to make it asynchronous}}