[Concurrency] Treat 'await' as a contextual keyword.

lib/Parse/ParseExpr.cpp

@@ -379,7 +379,7 @@ ParserResult<Expr> Parser::parseExprSequence(Diag<> Message,
 /// parseExprSequenceElement
 ///
 ///   expr-sequence-element(Mode):
-///     '__await' expr-sequence-element(Mode)
+///     'await' expr-sequence-element(Mode)
 ///     'try' expr-sequence-element(Mode)
 ///     'try' '?' expr-sequence-element(Mode)
 ///     'try' '!' expr-sequence-element(Mode)
@@ -392,8 +392,8 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
   SyntaxParsingContext ElementContext(SyntaxContext,
                                       SyntaxContextKind::Expr);
 
-  if (shouldParseExperimentalConcurrency() && Tok.is(tok::kw___await)) {
-    SourceLoc awaitLoc = consumeToken(tok::kw___await);
+  if (shouldParseExperimentalConcurrency() && Tok.isContextualKeyword("await")) {
+    SourceLoc awaitLoc = consumeToken();
     ParserResult<Expr> sub = parseExprUnary(message, isExprBasic);
     if (!sub.hasCodeCompletion() && !sub.isNull()) {
       ElementContext.setCreateSyntax(SyntaxKind::AwaitExpr);

test/Parse/async-syntax.swift

@@ -12,11 +12,15 @@ func testTypeExprs() {
 }
 
 func testAwaitOperator() async {
-  let _ = __await asyncGlobal1()
+  let _ = await asyncGlobal1()
 }
 
 func testAsyncClosure() {
   let _ = { () async in 5 }
   let _ = { () throws in 5 }
   let _ = { () async throws in 5 }
 }
+
+func testAwait() async {
+  let _ = await asyncGlobal1()
+}

test/Parse/async.swift

@@ -41,3 +41,14 @@ func testTypeExprs() {
 
   let _ = [() -> async ()]() // expected-error{{'async' may only occur before '->'}}{{18-24=}}{{15-15=async }}
 }
+
+// Parsing await syntax.
+struct MyFuture {
+  func await() -> Int { 0 }
+}
+
+func testAwaitExpr() async {
+  let _ = await asyncGlobal1()
+  let myFuture = MyFuture()
+  let _ = myFuture.await()
+}

test/Syntax/Parser/async.swift

@@ -16,7 +16,7 @@ func testTypeExprs() {
 }
 
 func testAwaitOperator() async {
-  let _ = __await asyncGlobal1()
+  let _ = await asyncGlobal1()
 }
 
 func testAsyncClosure() {

test/expr/unary/async_await.swift

@@ -1,36 +1,36 @@
 // RUN: %target-swift-frontend -typecheck -verify %s -enable-experimental-concurrency
 
 func test1(asyncfp : () async -> Int, fp : () -> Int) async {
-  _ = __await asyncfp()
-  _ = __await asyncfp() + asyncfp()
-  _ = __await asyncfp() + fp()
-  _ = __await fp() + 42  // expected-warning {{no calls to 'async' functions occur within 'await' expression}}
+  _ = await asyncfp()
+  _ = await asyncfp() + asyncfp()
+  _ = await asyncfp() + fp()
+  _ = await fp() + 42  // expected-warning {{no calls to 'async' functions occur within 'await' expression}}
   _ = asyncfp() // expected-error {{call is 'async' but is not marked with 'await'}}
 }
 
 func getInt() async -> Int { return 5 }
 
 // Locations where "await" is prohibited.
 func test2(
-  defaulted: Int = __await getInt() // expected-error{{'async' call cannot occur in a default argument}}
+  defaulted: Int = await getInt() // expected-error{{'async' call cannot occur in a default argument}}
 ) async {
   defer {
-    _ = __await getInt() // expected-error{{'async' call cannot occur in a defer body}}
+    _ = await getInt() // expected-error{{'async' call cannot occur in a defer body}}
   }
   print("foo")
 }
 
 func test3() { // expected-note{{add 'async' to function 'test3()' to make it asynchronous}}
-  _ = __await getInt() // expected-error{{'async' in a function that does not support concurrency}}
+  _ = await getInt() // expected-error{{'async' in a function that does not support concurrency}}
 }
 
 enum SomeEnum: Int {
-case foo = __await 5 // expected-error{{raw value for enum case must be a literal}}
+case foo = await 5 // expected-error{{raw value for enum case must be a literal}}
 }
 
 struct SomeStruct {
-  var x = __await getInt() // expected-error{{'async' call cannot occur in a property initializer}}
-  static var y = __await getInt() // expected-error{{'async' call cannot occur in a global variable initializer}}
+  var x = await getInt() // expected-error{{'async' call cannot occur in a property initializer}}
+  static var y = await getInt() // expected-error{{'async' call cannot occur in a global variable initializer}}
 }
 
 func acceptAutoclosureNonAsync(_: @autoclosure () -> Int) async { }
@@ -46,27 +46,27 @@ struct HasAsyncBad {
 }
 
 func testAutoclosure() async {
-  __await acceptAutoclosureAsync(getInt()) // expected-error{{call is 'async' in an autoclosure argument is not marked with 'await'}}
-  __await acceptAutoclosureNonAsync(getInt()) // expected-error{{'async' in an autoclosure that does not support concurrency}}
+  await acceptAutoclosureAsync(getInt()) // expected-error{{call is 'async' in an autoclosure argument is not marked with 'await'}}
+  await acceptAutoclosureNonAsync(getInt()) // expected-error{{'async' in an autoclosure that does not support concurrency}}
 
-  __await acceptAutoclosureAsync(__await getInt())
-  __await acceptAutoclosureNonAsync(__await getInt()) // expected-error{{'async' in an autoclosure that does not support concurrency}}
+  await acceptAutoclosureAsync(await getInt())
+  await acceptAutoclosureNonAsync(await getInt()) // expected-error{{'async' in an autoclosure that does not support concurrency}}
 
-  __await acceptAutoclosureAsync(getInt()) // expected-error{{call is 'async' in an autoclosure argument is not marked with 'await'}}
-  __await acceptAutoclosureNonAsync(getInt()) // expected-error{{'async' in an autoclosure that does not support concurrency}}
+  await acceptAutoclosureAsync(getInt()) // expected-error{{call is 'async' in an autoclosure argument is not marked with 'await'}}
+  await acceptAutoclosureNonAsync(getInt()) // expected-error{{'async' in an autoclosure that does not support concurrency}}
 }
 
 // Test inference of 'async' from the body of a closure.
 func testClosure() {
   let closure = {
-     __await getInt()
+     await getInt()
   }
 
   let _: () -> Int = closure // expected-error{{cannot convert value of type '() async -> Int' to specified type '() -> Int'}}
 
   let closure2 = { () async -> Int in
     print("here")
-    return __await getInt()
+    return await getInt()
   }
 
   let _: () -> Int = closure2 // expected-error{{cannot convert value of type '() async -> Int' to specified type '() -> Int'}}

utils/gyb_syntax_support/ExprNodes.py

@@ -49,7 +49,9 @@
     # await foo()
     Node('AwaitExpr', kind='Expr',
          children=[
-             Child('AwaitKeyword', kind='AwaitToken'),
+             Child('AwaitKeyword', kind='IdentifierToken',
+                   classification='Keyword',
+                   text_choices=['await']),
              Child('Expression', kind='Expr'),
          ]),
 

utils/gyb_syntax_support/Token.py

@@ -196,7 +196,6 @@ def macro_name(self):
     ExprKeyword('True', 'true', serialization_code=51),
     ExprKeyword('Try', 'try', serialization_code=52),
     ExprKeyword('Throws', 'throws', serialization_code=53),
-    ExprKeyword('Await', '__await', serialization_code=123),
 
     Keyword('__FILE__', '__FILE__', serialization_code=54),
     Keyword('__LINE__', '__LINE__', serialization_code=55),