[Concurrency] Require 'try' on accessing 'async let' with throwing initializer.

When an 'async let' initializer can throw, any access to one of the
variables in the 'async let' can also throw, so require such accesses
to be annotated with 'try'.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4067,6 +4067,8 @@ ERROR(throwing_interpolation_without_try,none,
       "interpolation can throw but is not marked with 'try'", ())
 ERROR(throwing_call_without_try,none,
       "call can throw but is not marked with 'try'", ())
+ERROR(throwing_async_let_without_try,none,
+      "reading 'async let' can throw but is not marked with 'try'", ())
 NOTE(note_forgot_try,none,
       "did you mean to use 'try'?", ())
 NOTE(note_error_to_optional,none,

lib/Sema/TypeCheckEffects.cpp

@@ -269,6 +269,9 @@ class PotentialThrowReason {
     /// The function calls an unconditionally throwing function.
     CallThrows,
 
+    /// The initializer of an 'async let' unconditionally throws.
+    AsyncLetThrows,
+
     /// The function is 'rethrows', and it was passed an explicit
     /// argument that was not rethrowing-only in this context.
     CallRethrowsWithExplicitThrowingArgument,
@@ -282,7 +285,8 @@ class PotentialThrowReason {
     switch (k) {
       case Kind::Throw: return "Throw";
       case Kind::CallThrows: return "CallThrows";
-      case Kind::CallRethrowsWithExplicitThrowingArgument: 
+      case Kind::AsyncLetThrows: return "AsyncLetThrows";
+      case Kind::CallRethrowsWithExplicitThrowingArgument:
         return "CallRethrowsWithExplicitThrowingArgument";
       case Kind::CallRethrowsWithDefaultThrowingArgument: 
         return "CallRethrowsWithDefaultThrowingArgument";
@@ -309,6 +313,9 @@ class PotentialThrowReason {
   static PotentialThrowReason forThrow() {
     return PotentialThrowReason(Kind::Throw);
   }
+  static PotentialThrowReason forThrowingAsyncLet() {
+    return PotentialThrowReason(Kind::AsyncLetThrows);
+  }
 
   Kind getKind() const { return TheKind; }
 
@@ -1124,6 +1131,7 @@ class Context {
     case PotentialThrowReason::Kind::Throw:
       llvm_unreachable("should already have been covered");
     case PotentialThrowReason::Kind::CallThrows:
+    case PotentialThrowReason::Kind::AsyncLetThrows:
       // Already fully diagnosed.
       return;
     case PotentialThrowReason::Kind::CallRethrowsWithExplicitThrowingArgument:
@@ -1141,6 +1149,9 @@ class Context {
                                   const PotentialThrowReason &reason) {
     auto &Diags = ctx.Diags;
     auto message = diag::throwing_call_without_try;
+    if (reason.getKind() == PotentialThrowReason::Kind::AsyncLetThrows)
+      message = diag::throwing_async_let_without_try;
+
     auto loc = E.getStartLoc();
     SourceLoc insertLoc;
     SourceRange highlight;
@@ -1781,10 +1792,25 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     if (auto decl = E->getDecl()) {
       if (auto var = dyn_cast<VarDecl>(decl)) {
         // "Async let" declarations are treated as an asynchronous call
-        // (to the underlying task's "get").
+        // (to the underlying task's "get"). If the initializer was throwing,
+        // then the access is also treated as throwing.
         if (var->isAsyncLet()) {
-          checkThrowAsyncSite(
-              E, /*requiresTry=*/false, Classification::forAsync());
+          // If the initializer could throw, we will have a 'try' in the
+          // application of its autoclosure.
+          bool throws = false;
+          if (auto init = var->getParentInitializer()) {
+            if (auto await = dyn_cast<AwaitExpr>(init))
+              init = await->getSubExpr();
+            if (isa<TryExpr>(init))
+              throws = true;
+          }
+
+          auto classification =
+            throws ? Classification::forThrow(
+                       PotentialThrowReason::forThrowingAsyncLet(),
+                       /*isAsync=*/true)
+                     : Classification::forAsync();
+          checkThrowAsyncSite(E, /*requiresTry=*/throws, classification);
         }
       }
     }

test/expr/unary/async_await.swift

@@ -173,8 +173,15 @@ func testAsyncLet() async throws {
 
   async let x2 = getInt() // expected-error{{call is 'async' in an 'async let' initializer that is not marked with 'await'}}
 
-  _ = await x1
+  async let x3 = try getIntUnsafely()
+  async let x4 = try! getIntUnsafely()
+  async let x5 = try? getIntUnsafely()
+
+  _ = await x1 // expected-error{{reading 'async let' can throw but is not marked with 'try'}}
   _ = await x2
+  _ = await try x3
+  _ = await x4
+  _ = await x5
 }
 
 // expected-note@+2 4{{add 'async' to function 'testAsyncLetOutOfAsync()' to make it asynchronous}}