Replace improper 'async' in parser

By replacing the 'async' with 'await' in the parser, we avoid the issue
of cascading errors as the compiler gets more and more confused by what
it's reading. Instead, everything mostly passes and we just emit the one
error message.

One caveat that I hadn't taken into account before was that we could
have a function called "async", in which case we don't want to replace
the "async" keyword with "await".

Author: etcwilde

include/swift/AST/DiagnosticsParse.def

@@ -958,7 +958,6 @@ ERROR(snake_case_deprecated,none,
       "%0 has been replaced with %1 in Swift 3",
       (StringRef, StringRef))
 
-
 // Assignment statement
 ERROR(expected_expr_assignment,none,
       "expected expression in assignment", ())
@@ -986,6 +985,10 @@ NOTE(indent_expression_to_silence,none,
 ERROR(expected_expr_throw,PointsToFirstBadToken,
       "expected expression in 'throw' statement", ())
 
+// Await/Async
+ERROR(expected_await_not_async,none,
+      "found 'async' in expression; did you mean 'await'?", ())
+
 // Yield Statment
 ERROR(expected_expr_yield,PointsToFirstBadToken,
       "expected expression in 'yield' statement", ())

lib/Parse/ParseExpr.cpp

@@ -399,8 +399,17 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
   SyntaxParsingContext ElementContext(SyntaxContext,
                                       SyntaxContextKind::Expr);
 
-  if (Tok.isContextualKeyword("await")) {
-    if (shouldParseExperimentalConcurrency()) {
+  if (shouldParseExperimentalConcurrency()) {
+    // A function called "async" is possible, so we don't want to replace it
+    // with await.
+    bool isReplaceableAsync = Tok.isContextualKeyword("async") &&
+                              !peekToken().is(tok::l_paren);
+    if (Tok.isContextualKeyword("await") || isReplaceableAsync) {
+      // Error on a replaceable async
+      if (isReplaceableAsync) {
+        diagnose(Tok.getLoc(), diag::expected_await_not_async)
+          .fixItReplace(Tok.getLoc(), "await");
+      }
       SourceLoc awaitLoc = consumeToken();
       ParserResult<Expr> sub =
         parseExprSequenceElement(diag::expected_expr_after_await, isExprBasic);
@@ -416,12 +425,12 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
         sub = makeParserResult(new (Context) AwaitExpr(awaitLoc, sub.get()));
       }
 
-      return sub;
-    } else {
-      // warn that future versions of Swift will parse this token differently.
-      diagnose(Tok.getLoc(), diag::warn_await_keyword)
-        .fixItReplace(Tok.getLoc(), "`await`");
+     return sub;
     }
+  } else if (Tok.isContextualKeyword("await")) {
+    // warn that future versions of Swift will parse this token differently.
+    diagnose(Tok.getLoc(), diag::warn_await_keyword)
+      .fixItReplace(Tok.getLoc(), "`await`");
   }
 
   SourceLoc tryLoc;

lib/Sema/PreCheckExpr.cpp

@@ -519,15 +519,7 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
         diag.highlight(UDRE->getSourceRange());
         typo->addFixits(diag);
       } else {
-        if (Name.isSimpleName("async")) {
-          auto diag = Context.Diags.diagnose(Loc,
-              diag::cannot_find_in_scope_corrected, Name,
-              /*isOperator=*/false, "await");
-          diag.highlight(UDRE->getSourceRange());
-          diag.fixItReplace(Loc, "await");
-        } else {
-          emitBasicError();
-        }
+        emitBasicError();
       }
 
       corrections.noteAllCandidates();

test/Concurrency/await_typo_correction.swift

@@ -7,25 +7,21 @@ func anotherAsyncFunc() async -> Int {
   return 42
 }
 
+func async() throws { }
+
 @main struct MyProgram {
   static func main() async throws {
-    // expected-error@+7 {{cannot find 'async' in scope; did you mean 'await'?}}{{9-14=await}}
-    // expected-error@+6 {{consecutive statements on a line must be separated by ';'}}
-    // expected-error@+5 {{call is 'async' but is not marked with 'await'}}
-    // expected-error@+4 {{call can throw but is not marked with 'try'}}
-    // expected-note@+3 {{did you mean to use 'try'?}}
-    // expected-note@+2 {{did you mean to handle error as optional value?}}
-    // expected-note@+1 {{did you mean to disable error propagation?}}
+    // expected-error@+1 {{found 'async' in expression; did you mean 'await'?}}{{9-14=await}}
     try async asyncFunc()
 
-    // expected-error@+4 {{consecutive statements on a line must be separated by ';'}}
-    // expected-error@+3 {{cannot find 'async' in scope; did you mean 'await'?}}{{13-18=await}}
-    // expected-warning@+2 {{result of call to 'anotherAsyncFunc()' is unused}}
-    // expected-error@+1 {{call is 'async' but is not marked with 'await'}}
+    // expected-error@+1 {{found 'async' in expression; did you mean 'await'?}}{{13-18=await}}
     let _ = async anotherAsyncFunc()
 
     // Don't emit a diagnostic here
     async let foo = anotherAsyncFunc()
     let _ = await foo
+
+    // I question the name choice, but it's valid
+    try async()
   }
 }