[Concurrency] Parse 'async let' declarations.

Perform very basic semantic analysis for their well-formedness.

Author: DougGregor

include/swift/AST/Attr.def

@@ -588,6 +588,12 @@ SIMPLE_DECL_ATTR(_specializeExtension, SpecializeExtension,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   105)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(async, Async,
+  DeclModifier | OnVar | OnFunc | ConcurrencyOnly |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  106)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsParse.def

@@ -324,6 +324,8 @@ ERROR(func_decl_expected_arrow,none,
 ERROR(operator_static_in_protocol,none,
       "operator '%0' declared in protocol must be 'static'",
       (StringRef))
+ERROR(async_func_modifier,none,
+      "'async' must be written after the parameter list of a function", ())
 
 // Enum
 ERROR(expected_lbrace_enum,PointsToFirstBadToken,

include/swift/AST/DiagnosticsSema.def

@@ -4118,6 +4118,15 @@ NOTE(protocol_witness_async_conflict,none,
 ERROR(async_autoclosure_nonasync_function,none,
       "'async' autoclosure parameter in a non-'async' function", ())
 
+ERROR(async_not_let,none,
+      "'async' can only be used with 'let' declarations", ())
+ERROR(async_let_not_local,none,
+      "'async let' can only be used on local declarations", ())
+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(asynchandler_non_func,none,
       "'@asyncHandler' can only be applied to functions",
       ())

lib/Parse/ParseDecl.cpp

@@ -6558,6 +6558,19 @@ ParserResult<FuncDecl> Parser::parseDeclFunc(SourceLoc StaticLoc,
 
   diagnoseWhereClauseInGenericParamList(GenericParams);
 
+  // If there was an 'async' modifier, put it in the right place for a function.
+  bool isAsync = asyncLoc.isValid();
+  if (auto asyncAttr = Attributes.getAttribute<AsyncAttr>()) {
+    SourceLoc insertLoc = Lexer::getLocForEndOfToken(
+        SourceMgr, BodyParams->getRParenLoc());
+
+    diagnose(asyncAttr->getLocation(), diag::async_func_modifier)
+      .fixItRemove(asyncAttr->getRange())
+      .fixItInsert(insertLoc, " async");
+    asyncAttr->setInvalid();
+    isAsync = true;
+  }
+
   // Create the decl for the func and add it to the parent scope.
   auto *FD = FuncDecl::create(Context, StaticLoc, StaticSpelling,
                               FuncLoc, FullName, NameLoc,

lib/Sema/TypeCheckAttr.cpp

@@ -344,6 +344,59 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
 
     (void)nominal->isGlobalActor();
   }
+
+  void visitAsyncAttr(AsyncAttr *attr) {
+    auto var = dyn_cast<VarDecl>(D);
+    if (!var)
+      return;
+
+    auto patternBinding = var->getParentPatternBinding();
+    if (!patternBinding)
+      return; // already diagnosed
+
+    // "Async" modifier can only be applied to local declarations.
+    if (!patternBinding->getDeclContext()->isLocalContext()) {
+      diagnoseAndRemoveAttr(attr, diag::async_let_not_local);
+      return;
+    }
+
+    // Check each of the pattern binding entries.
+    bool diagnosedVar = false;
+    for (unsigned index : range(patternBinding->getNumPatternEntries())) {
+      auto pattern = patternBinding->getPattern(index);
+
+      // Look for variables bound by this pattern.
+      bool foundAnyVariable = false;
+      bool isLet = true;
+      pattern->forEachVariable([&](VarDecl *var) {
+        if (!var->isLet())
+          isLet = false;
+        foundAnyVariable = true;
+      });
+
+      // Each entry must bind at least one named variable, so that there is
+      // something to "await".
+      if (!foundAnyVariable) {
+        diagnose(pattern->getLoc(), diag::async_let_no_variables);
+        attr->setInvalid();
+        return;
+      }
+
+      // Async can only be used on an "async let".
+      if (!isLet && !diagnosedVar) {
+        diagnose(patternBinding->getLoc(), diag::async_not_let)
+          .fixItReplace(patternBinding->getLoc(), "let");
+        diagnosedVar = true;
+      }
+
+      // Each pattern entry must have an initializer expression.
+      if (patternBinding->getEqualLoc(index).isInvalid()) {
+        diagnose(pattern->getLoc(), diag::async_let_not_initialized);
+        attr->setInvalid();
+        return;
+      }
+    }
+  }
 };
 } // end anonymous namespace
 

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1516,6 +1516,7 @@ namespace  {
     UNINTERESTING_ATTR(Actor)
     UNINTERESTING_ATTR(ActorIndependent)
     UNINTERESTING_ATTR(GlobalActor)
+    UNINTERESTING_ATTR(Async)
 #undef UNINTERESTING_ATTR
 
     void visitAvailableAttr(AvailableAttr *attr) {

test/Parse/async.swift

@@ -54,3 +54,12 @@ func testAwaitExpr() async {
   let myFuture = MyFuture()
   let _ = myFuture.await()
 }
+
+func getIntSomeday() async -> Int { 5 }
+
+func testAsyncLet() async {
+  async let x = await getIntSomeday()
+  _ = 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

@@ -0,0 +1,26 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-concurrency
+
+// REQUIRES: concurrency
+
+async let x = 1 // okay
+
+struct X {
+  async let x = 1 // expected-error{{'async let' can only be used on local declarations}}
+}
+
+func testAsyncFunc() async {
+  async let (z1, z2) = (2, 3)
+  async let (_, _) = (2, 3)
+  async let x2 = 1
+
+  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
+  _ = y
+  _ = z1
+  _ = z2
+  _ = x2
+  x = 1
+  _ = y2
+}

utils/gyb_syntax_support/DeclNodes.py

@@ -171,7 +171,7 @@
                        'required', 'static', 'unowned', 'weak', 'private',
                        'fileprivate', 'internal', 'public', 'open',
                        'mutating', 'nonmutating', 'indirect', '__consuming',
-                       'actor'
+                       'actor', 'async'
                    ]),
              Child('DetailLeftParen', kind='LeftParenToken', is_optional=True),
              Child('Detail', kind='IdentifierToken', is_optional=True),