Sema: Reject captures of async let bindings.

This isn't implemented. It would never make sense for escaping captures of
`async let` values, because doing so would either involve an implicit awaiting
of the value on capture, or else stretching the lifetime of the task past its
scope. In nonescaping contexts, and in nested `async let` expressions, it might
be implementable in the future. rdar://80043610

Author: jckarter

include/swift/AST/DiagnosticsSema.def

@@ -3698,6 +3698,10 @@ WARNING(partial_application_of_function_invalid_swift4,none,
       "be an error in future Swift versions",
       (unsigned))
 
+// Cannot capture `async let`
+ERROR(capture_async_let_not_supported,none,
+      "capturing 'async let' variables is not supported", ())
+
 ERROR(self_assignment_var,none,
       "assigning a variable to itself", ())
 ERROR(self_assignment_prop,none,

lib/Sema/TypeCheckCaptures.cpp

@@ -177,6 +177,14 @@ class FindCapturedVars : public ASTWalker {
   /// if invalid.
   void addCapture(CapturedValue capture) {
     auto VD = capture.getDecl();
+    
+    if (auto var = dyn_cast<VarDecl>(VD)) {
+      // `async let` variables cannot currently be captured.
+      if (var->isAsyncLet()) {
+        Context.Diags.diagnose(capture.getLoc(), diag::capture_async_let_not_supported);
+        return;
+      }
+    }
 
     // Check to see if we already have an entry for this decl.
     unsigned &entryNumber = captureEntryNumber[VD];

test/Concurrency/async_let_capture.swift

@@ -0,0 +1,17 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-experimental-concurrency
+// REQUIRES: concurrency
+
+func autoclosureCapture(_: @autoclosure () async throws -> Int) async {}
+func nonescapingCapture(_: () async throws -> Int) {}
+func escapingCapture(_: @escaping () async throws -> Int) {}
+
+func foo() async {
+    async let x = 32
+
+    async let y = x // expected-error{{not supported}}
+    _ = await y
+
+    await autoclosureCapture(await x)// expected-error{{not supported}}
+    nonescapingCapture { await x }// expected-error{{not supported}}
+    escapingCapture { await x }// expected-error{{not supported}}
+}