[Concurrency] Diagnose 'async let' declarations in non-async contexts.

Author: DougGregor

include/swift/AST/Decl.h

@@ -1784,6 +1784,9 @@ class PatternBindingDecl final : public Decl,
   /// Is the pattern binding entry for this variable  currently being computed?
   bool isComputingPatternBindingEntry(const VarDecl *vd) const;
 
+  /// Is this an "async let" declaration.
+  bool isAsyncLet() const;
+
   /// Gets the text of the initializer expression for the pattern entry at the
   /// given index, stripping out inactive branches of any #ifs inside the
   /// expression.

lib/AST/Decl.cpp

@@ -1545,6 +1545,13 @@ StaticSpellingKind PatternBindingDecl::getCorrectStaticSpelling() const {
   return getCorrectStaticSpellingForDecl(this);
 }
 
+bool PatternBindingDecl::isAsyncLet() const {
+  if (auto var = getAnchoringVarDecl(0))
+    return var->isAsyncLet();
+
+  return false;
+}
+
 
 bool PatternBindingDecl::hasStorage() const {
   // Walk the pattern, to check to see if any of the VarDecls included in it

lib/Sema/TypeCheckEffects.cpp

@@ -194,10 +194,14 @@ class EffectsHandlingWalker : public ASTWalker {
     ShouldRecurse_t recurse = ShouldRecurse;
     // Skip the implementations of all local declarations... except
     // PBD.  We should really just have a PatternBindingStmt.
-    if (auto ic = dyn_cast<IfConfigDecl>(D))
+    if (auto ic = dyn_cast<IfConfigDecl>(D)) {
       recurse = asImpl().checkIfConfig(ic);
-    else if (!isa<PatternBindingDecl>(D))
+    } else if (auto patternBinding = dyn_cast<PatternBindingDecl>(D)) {
+      if (patternBinding->isAsyncLet())
+        recurse = asImpl().checkAsyncLet(patternBinding);
+    } else {
       recurse = ShouldNotRecurse;
+    }
     return bool(recurse);
   }
 
@@ -661,6 +665,9 @@ class ApplyClassifier {
     ShouldRecurse_t checkDeclRef(DeclRefExpr *E) {
       return ShouldNotRecurse;
     }
+    ShouldRecurse_t checkAsyncLet(PatternBindingDecl *patternBinding) {
+      return ShouldRecurse;
+    }
     ShouldRecurse_t checkThrow(ThrowStmt *E) {
       Result = ThrowingKind::Throws;
       return ShouldRecurse;
@@ -1321,6 +1328,15 @@ class Context {
           }
         }
       }
+    } else if (auto patternBinding = dyn_cast_or_null<PatternBindingDecl>(
+                   node.dyn_cast<Decl *>())) {
+      if (patternBinding->isAsyncLet()) {
+        auto var = patternBinding->getAnchoringVarDecl(0);
+        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,
@@ -1344,7 +1360,8 @@ class Context {
       unsigned kind = 0;
       if (node.isExpr(ExprKind::Await))
         kind = 1;
-      else if (node.isExpr(ExprKind::DeclRef))
+      else if (node.isExpr(ExprKind::DeclRef) ||
+               node.isDecl(DeclKind::PatternBinding))
         kind = 2;
       Diags.diagnose(node.getStartLoc(), diag::async_in_nonasync_function,
                      kind, isAutoClosure());
@@ -1743,6 +1760,14 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     return ShouldNotRecurse;
   }
 
+  ShouldRecurse_t checkAsyncLet(PatternBindingDecl *patternBinding) {
+      // Diagnose async calls in a context that doesn't handle async.
+      if (!CurContext.handlesAsync()) {
+        CurContext.diagnoseUnhandledAsyncSite(Ctx.Diags, patternBinding);
+      }
+    return ShouldRecurse;
+  }
+
   ShouldRecurse_t
   checkInterpolatedStringLiteral(InterpolatedStringLiteralExpr *E) {
     ContextScope scope(*this, CurContext.withInterpolatedString(E));

test/expr/unary/async_await.swift

@@ -164,10 +164,10 @@ func testAsyncLet() async throws {
   }
 }
 
-// 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}}
+// expected-note@+2 3{{add 'async' to function 'testAsyncLetOutOfAsync()' to make it asynchronous}}
+// expected-note@+1 3{{add '@asyncHandler' to function 'testAsyncLetOutOfAsync()' to create an implicit asynchronous context}}
 func testAsyncLetOutOfAsync() {
-  async let x = 1 // ERROR?
+  async let x = 1 // expected-error{{'async let' in a function that does not support concurrency}}
 
   _ = 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}}