Merge pull request #35153 from kavon/warn-unqualified-await

[concurrency] warn about future reservation of 'await' as contextual keyword

Author: kavon

include/swift/AST/DiagnosticsParse.def

@@ -1224,6 +1224,9 @@ NOTE(super_in_closure_with_capture_here,none,
      "'self' explicitly captured here", ())
 
 ERROR(try_before_await,none, "'await' must precede 'try'", ())
+WARNING(warn_await_keyword,none, 
+      "future versions of Swift reserve the word 'await'; "
+      "if this name is unavoidable, use backticks to escape it", ())
 
 // Tuples and parenthesized expressions
 ERROR(expected_expr_in_expr_list,none,

lib/Parse/ParseExpr.cpp

@@ -399,16 +399,22 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
   SyntaxParsingContext ElementContext(SyntaxContext,
                                       SyntaxContextKind::Expr);
 
-  if (shouldParseExperimentalConcurrency() && Tok.isContextualKeyword("await")) {
-    SourceLoc awaitLoc = consumeToken();
-    ParserResult<Expr> sub =
-      parseExprSequenceElement(diag::expected_expr_after_await, isExprBasic);
-    if (!sub.hasCodeCompletion() && !sub.isNull()) {
-      ElementContext.setCreateSyntax(SyntaxKind::AwaitExpr);
-      sub = makeParserResult(new (Context) AwaitExpr(awaitLoc, sub.get()));
-    }
+  if (Tok.isContextualKeyword("await")) {
+    if (shouldParseExperimentalConcurrency()) {
+      SourceLoc awaitLoc = consumeToken();
+      ParserResult<Expr> sub =
+        parseExprSequenceElement(diag::expected_expr_after_await, isExprBasic);
+      if (!sub.hasCodeCompletion() && !sub.isNull()) {
+        ElementContext.setCreateSyntax(SyntaxKind::AwaitExpr);
+        sub = makeParserResult(new (Context) AwaitExpr(awaitLoc, sub.get()));
+      }
 
-    return sub;
+      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`");
+    }
   }
 
   SourceLoc tryLoc;

test/Compatibility/unescaped_await.swift

@@ -0,0 +1,68 @@
+// RUN: %target-typecheck-verify-swift
+    // now check that the fix-its, if applied, will fix the warnings.
+// RUN: %empty-directory(%t.scratch)
+// RUN: cp %s %t.scratch/fixits.swift
+// RUN: %target-swift-frontend -typecheck %t.scratch/fixits.swift -fixit-all -emit-fixits-path %t.scratch/fixits.remap 2> /dev/null
+// RUN: %{python} %utils/apply-fixit-edits.py %t.scratch
+// RUN: %target-swift-frontend -typecheck %t.scratch/fixits.swift -warnings-as-errors
+// RUN: %target-swift-frontend -typecheck %t.scratch/fixits.swift -warnings-as-errors -enable-experimental-concurrency
+
+// REQUIRES: concurrency
+
+func await(_ f : () -> Void) {}
+
+func ordinaryCalls() {
+  await({})
+  // expected-warning@-1 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+
+  await {}
+  // expected-warning@-1 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+
+  let _ = `await`
+  let _ = `await`({})
+  
+  let _ = await
+  // expected-warning@-1 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+
+  let k = Klass()
+  k.await()
+  _ = k.await
+}
+
+func localVar() {
+  var await = 1
+
+  let two = await + await
+  // expected-warning@-1 2 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+  
+  _ = await==two-await
+  // expected-warning@-1 2 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+
+  takesInout(await: &await)
+}
+
+func takesUnitFunc(_ f : () -> Void) {}
+
+func takesInout(await : inout Int) {
+  await += 1
+  // expected-warning@-1 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+}
+
+class Klass {
+  init() { await() }
+  // expected-warning@-1 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+
+  func await() {
+
+    takesUnitFunc(await)
+    // expected-warning@-1 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+  }
+
+  func method() {
+    let _ = self.await
+    self.await()
+
+    await()
+    // expected-warning@-1 {{future versions of Swift reserve the word 'await'; if this name is unavoidable, use backticks to escape it}}
+  }
+}