[Concurrency] Require references to 'async let' to have an 'await'.

Extend effects checking to ensure that each reference to a variable
bound by an 'async let' is covered by an "await" expression and occurs
in a suitable context.

Author: DougGregor

include/swift/AST/Decl.h

@@ -4727,6 +4727,9 @@ class VarDecl : public AbstractStorageDecl {
   /// getSpecifier() == Specifier::Default.
   bool isLet() const { return getIntroducer() == Introducer::Let; }
 
+  /// Is this an "async let" property?
+  bool isAsyncLet() const;
+
   Introducer getIntroducer() const {
     return Introducer(Bits.VarDecl.Introducer);
   }

include/swift/AST/DiagnosticsSema.def

@@ -4098,9 +4098,9 @@ ERROR(await_in_illegal_context,none,
       "%select{<<ERROR>>|a default argument|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
       (unsigned))
 ERROR(async_in_nonasync_function,none,
-      "%select{'async'|'await'}0 in %select{a function|an autoclosure}1 that "
-      "does not support concurrency",
-      (bool, bool))
+      "%select{'async'|'await'|'async let'}0 in "
+      "%select{a function|an autoclosure}1 that does not support concurrency",
+      (unsigned, bool))
 NOTE(note_add_async_to_function,none,
      "add 'async' to function %0 to make it asynchronous", (DeclName))
 NOTE(note_add_asynchandler_to_function,none,
@@ -4126,6 +4126,12 @@ ERROR(async_let_not_initialized,none,
       "'async let' binding requires an initializer expression", ())
 ERROR(async_let_no_variables,none,
       "'async let' requires at least one named variable", ())
+ERROR(async_let_without_await,none,
+      "reference to async let %0 is not marked with 'await'", (DeclName))
+ERROR(async_let_in_illegal_context,none,
+      "async let %0 cannot be referenced in "
+      "%select{<<ERROR>>|a default argument|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}1",
+      (DeclName, unsigned))
 
 ERROR(asynchandler_non_func,none,
       "'@asyncHandler' can only be applied to functions",

lib/AST/Decl.cpp

@@ -5740,6 +5740,10 @@ bool VarDecl::isMemberwiseInitialized(bool preferDeclaredProperties) const {
   return true;
 }
 
+bool VarDecl::isAsyncLet() const {
+  return getAttrs().hasAttribute<AsyncAttr>();
+}
+
 void ParamDecl::setSpecifier(Specifier specifier) {
   // FIXME: Revisit this; in particular shouldn't __owned parameters be
   // ::Let also?

lib/Sema/TypeCheckEffects.cpp

@@ -219,6 +219,8 @@ class EffectsHandlingWalker : public ASTWalker {
       recurse = asImpl().checkOptionalTry(optionalTryExpr);
     } else if (auto apply = dyn_cast<ApplyExpr>(E)) {
       recurse = asImpl().checkApply(apply);
+    } else if (auto declRef = dyn_cast<DeclRefExpr>(E)) {
+      recurse = asImpl().checkDeclRef(declRef);
     } else if (auto interpolated = dyn_cast<InterpolatedStringLiteralExpr>(E)) {
       recurse = asImpl().checkInterpolatedStringLiteral(interpolated);
     }
@@ -656,6 +658,9 @@ class ApplyClassifier {
       Result = std::max(Result, classification.getResult());
       return ShouldRecurse;
     }
+    ShouldRecurse_t checkDeclRef(DeclRefExpr *E) {
+      return ShouldNotRecurse;
+    }
     ShouldRecurse_t checkThrow(ThrowStmt *E) {
       Result = ThrowingKind::Throws;
       return ShouldRecurse;
@@ -1271,6 +1276,18 @@ class Context {
     SourceRange highlight;
 
     // Generate more specific messages in some cases.
+
+    // Reference to an 'async let' missing an 'await'.
+    if (auto declRef = dyn_cast_or_null<DeclRefExpr>(node.dyn_cast<Expr *>())) {
+      if (auto var = dyn_cast<VarDecl>(declRef->getDecl())) {
+        if (var->isAsyncLet()) {
+          ctx.Diags.diagnose(
+              declRef->getLoc(), diag::async_let_without_await, var->getName());
+          return;
+        }
+      }
+    }
+
     if (auto apply = dyn_cast_or_null<ApplyExpr>(node.dyn_cast<Expr*>()))
       highlight = apply->getSourceRange();
 
@@ -1293,6 +1310,17 @@ class Context {
                        static_cast<unsigned>(getKind()));
         return;
       }
+
+      if (auto declRef = dyn_cast<DeclRefExpr>(e)) {
+        if (auto var = dyn_cast<VarDecl>(declRef->getDecl())) {
+          if (var->isAsyncLet()) {
+            Diags.diagnose(
+                e->getLoc(), diag::async_let_in_illegal_context,
+                var->getName(), static_cast<unsigned>(getKind()));
+            return;
+          }
+        }
+      }
     }
 
     Diags.diagnose(node.getStartLoc(), diag::await_in_illegal_context,
@@ -1312,11 +1340,17 @@ class Context {
 
   void diagnoseUnhandledAsyncSite(DiagnosticEngine &Diags, ASTNode node) {
     switch (getKind()) {
-    case Kind::PotentiallyHandled:
+    case Kind::PotentiallyHandled: {
+      unsigned kind = 0;
+      if (node.isExpr(ExprKind::Await))
+        kind = 1;
+      else if (node.isExpr(ExprKind::DeclRef))
+        kind = 2;
       Diags.diagnose(node.getStartLoc(), diag::async_in_nonasync_function,
-                     node.isExpr(ExprKind::Await), isAutoClosure());
+                     kind, isAutoClosure());
       maybeAddAsyncNote(Diags);
       return;
+    }
 
     case Kind::EnumElementInitializer:
     case Kind::GlobalVarInitializer:
@@ -1694,6 +1728,21 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     return !type || type->hasError() ? ShouldNotRecurse : ShouldRecurse;
   }
 
+  ShouldRecurse_t checkDeclRef(DeclRefExpr *E) {
+    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").
+        if (var->isAsyncLet()) {
+          checkThrowAsyncSite(
+              E, /*requiresTry=*/false, Classification::forAsync());
+        }
+      }
+    }
+
+    return ShouldNotRecurse;
+  }
+
   ShouldRecurse_t
   checkInterpolatedStringLiteral(InterpolatedStringLiteralExpr *E) {
     ContextScope scope(*this, CurContext.withInterpolatedString(E));

test/Parse/async.swift

@@ -59,7 +59,7 @@ func getIntSomeday() async -> Int { 5 }
 
 func testAsyncLet() async {
   async let x = await getIntSomeday()
-  _ = x
+  _ = await x
 }
 
 async func asyncIncorrectly() { } // expected-error{{'async' must be written after the parameter list of a function}}{{1-7=}}{{30-30= async}}

test/decl/var/async_let.swift

@@ -16,11 +16,11 @@ func testAsyncFunc() async {
   async var x = 17 // expected-error{{'async' can only be used with 'let' declarations}}{{9-12=let}}
   async let (_, _) = (1, 2), y2 = 7 // expected-error{{'async let' requires at least one named variable}}
   async let y: Int // expected-error{{'async let' binding requires an initializer expression}}
-  _ = x
+  _ = await x
   _ = y
-  _ = z1
-  _ = z2
-  _ = x2
-  x = 1
+  _ = await z1
+  _ = await z2
+  _ = await x2
+  await x = 1
   _ = y2
 }

test/expr/unary/async_await.swift

@@ -144,3 +144,32 @@ func invalidAsyncFunction() async {
 func validAsyncFunction() async throws {
   _ = try await throwingAndAsync()
 }
+
+// Async let checking
+func mightThrow() throws { }
+
+extension Error {
+  var number: Int { 0 }
+}
+
+func testAsyncLet() async throws {
+  async let x = await getInt()
+  print(x) // expected-error{{reference to async let 'x' is not marked with 'await'}}
+  print(await x)
+
+  do {
+    try mightThrow()
+  } catch let e where e.number == x { // expected-error{{async let 'x' cannot be referenced in a catch guard expression}}
+  } catch {
+  }
+}
+
+// expected-note@+2 2{{add 'async' to function 'testAsyncLetOutOfAsync()' to make it asynchronous}}
+// expected-note@+1 2{{add '@asyncHandler' to function 'testAsyncLetOutOfAsync()' to create an implicit asynchronous context}}
+func testAsyncLetOutOfAsync() {
+  async let x = 1 // ERROR?
+
+  _ = await x  // expected-error{{'async let' in a function that does not support concurrency}}
+  _ = x // expected-error{{'async let' in a function that does not support concurrency}}
+}
+