Version 2.18.0-236.0.dev

Merge commit 'dd9a2dca24a5a50bffcb088368b003414c737aa3' into 'dev'

Author: Dart CI

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -5015,7 +5015,7 @@ class Parser {
           if (optional(':', token.next!.next!)) {
             return parseLabeledStatement(token);
           }
-          if (looksLikeYieldStatement(token)) {
+          if (looksLikeYieldStatement(token, AwaitOrYieldContext.Statement)) {
             // Recovery: looks like an expression preceded by `yield` but not
             // inside an Async or AsyncStar context. parseYieldStatement will
             // report the error.
@@ -5035,7 +5035,7 @@ class Parser {
       return parseExpressionStatementOrConstDeclaration(token);
     } else if (identical(value, 'await')) {
       if (inPlainSync) {
-        if (!looksLikeAwaitExpression(token)) {
+        if (!looksLikeAwaitExpression(token, AwaitOrYieldContext.Statement)) {
           return parseExpressionStatementOrDeclaration(token);
         }
         // Recovery: looks like an expression preceded by `await`
@@ -5648,7 +5648,8 @@ class Parser {
     // Prefix:
     if (identical(value, 'await')) {
       if (inPlainSync) {
-        if (!looksLikeAwaitExpression(token)) {
+        if (!looksLikeAwaitExpression(
+            token, AwaitOrYieldContext.UnaryExpression)) {
           return parsePrimary(token, IdentifierContext.expression);
         }
         // Recovery: Looks like an expression preceded by `await`.
@@ -7562,7 +7563,8 @@ class Parser {
 
   /// Determine if the following tokens look like an expression and not a local
   /// variable or local function declaration.
-  bool looksLikeExpression(Token token) {
+  bool looksLikeExpressionAfterAwaitOrYield(
+      Token token, AwaitOrYieldContext context) {
     // TODO(srawlins): Consider parsing the potential expression once doing so
     //  does not modify the token stream. For now, use simple look ahead and
     //  ensure no false positives.
@@ -7572,14 +7574,36 @@ class Parser {
       token = token.next!;
       if (optional('(', token)) {
         token = token.endGroup!.next!;
-        if (isOneOf(token, [';', '.', '..', '?', '?.'])) {
+        if (isOneOf(token, const [';', '.', ',', '..', '?', '?.', ')'])) {
+          // E.g. (in a non-async function): `await f();`.
+          return true;
+        } else if (token.type.isBinaryOperator) {
+          // E.g. (in a non-async function):
+          // `await returnsFuture() + await returnsFuture()`.
           return true;
         }
-      } else if (isOneOf(token, ['.', ')', ']'])) {
+      } else if (isOneOf(token, const ['.', ')', ']'])) {
         // TODO(srawlins): Also consider when `token` is `;`. There is still not
         // good error recovery on `yield x;`. This would also require
         // modification to analyzer's
         // test_parseCompilationUnit_pseudo_asTypeName.
+
+        // E.g. (in a non-async function): `if (await f) {}`.
+        return true;
+      } else if (optional(',', token) &&
+          context == AwaitOrYieldContext.UnaryExpression) {
+        // E.g. (in a non-async function): `xor(await f, await f, await f);`,
+        // but not `await y, z` (`await` is a class here so it's declaring two
+        // variables).
+        return true;
+      } else if (token.type.isBinaryOperator) {
+        // E.g. (in a non-async function): (first part of) `await f + await f;`,
+        return true;
+      } else if (optional(';', token) &&
+          context == AwaitOrYieldContext.UnaryExpression) {
+        // E.g. (in a non-async function): (second part of) `await f + await f;`
+        // but not `await f;` (`await` is a class here so it's a variable
+        // declaration).
         return true;
       }
     } else if (token == Keyword.NULL) {
@@ -7596,20 +7620,20 @@ class Parser {
 
   /// Determine if the following tokens look like an 'await' expression
   /// and not a local variable or local function declaration.
-  bool looksLikeAwaitExpression(Token token) {
+  bool looksLikeAwaitExpression(Token token, AwaitOrYieldContext context) {
     token = token.next!;
     assert(optional('await', token));
 
-    return looksLikeExpression(token);
+    return looksLikeExpressionAfterAwaitOrYield(token, context);
   }
 
   /// Determine if the following tokens look like a 'yield' expression and not a
   /// local variable or local function declaration.
-  bool looksLikeYieldStatement(Token token) {
+  bool looksLikeYieldStatement(Token token, AwaitOrYieldContext context) {
     token = token.next!;
     assert(optional('yield', token));
 
-    return looksLikeExpression(token);
+    return looksLikeExpressionAfterAwaitOrYield(token, context);
   }
 
   /// ```
@@ -8724,3 +8748,5 @@ class Parser {
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.
 typedef _MessageWithArgument<T> = codes.Message Function(T);
+
+enum AwaitOrYieldContext { Statement, UnaryExpression }

pkg/analyzer/test/generated/class_member_parser_test.dart

@@ -5,6 +5,7 @@
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/error/codes.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -143,15 +144,143 @@ class ClassMemberParserTest extends FastaParserTestCase
     var method = parser.parseClassMember('C') as MethodDeclaration;
     expect(method, isNotNull);
     listener.assertErrors([
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 13, 5),
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 23, 5)
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 13, 5),
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 23, 5)
     ]);
     FunctionBody body = method.body;
     expect(body, isBlockFunctionBody);
     Statement statement = (body as BlockFunctionBody).block.statements[0];
     expect(statement, isReturnStatement);
     Expression expression = (statement as ReturnStatement).expression!;
     expect(expression, isBinaryExpression);
+    expect((expression as BinaryExpression).leftOperand, isAwaitExpression);
+    expect(expression.rightOperand, isAwaitExpression);
+  }
+
+  void test_parseAwaitExpression_inSync_v1_49116() {
+    createParser('m() { await returnsFuture(); }');
+    var method = parser.parseClassMember('C') as MethodDeclaration;
+    expect(method, isNotNull);
+    listener.assertErrors([
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 6, 5),
+    ]);
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isExpressionStatement);
+    Expression expression = (statement as ExpressionStatement).expression;
+    expect(expression, isAwaitExpression);
+  }
+
+  void test_parseAwaitExpression_inSync_v2_49116() {
+    createParser('''m() {
+      if (await returnsFuture()) {}
+      else if (!await returnsFuture()) {}
+    }''');
+    var method = parser.parseClassMember('C') as MethodDeclaration;
+    expect(method, isNotNull);
+    listener.assertErrors([
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 16, 5),
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 58, 5),
+    ]);
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isIfStatement);
+    Expression expression = (statement as IfStatement).condition;
+    expect(expression, isAwaitExpression);
+    expect(statement.elseStatement, isNotNull);
+    Statement elseStatement = statement.elseStatement!;
+    expect(elseStatement, isIfStatement);
+    expression = (elseStatement as IfStatement).condition;
+    expect(expression, isPrefixExpression);
+    expect((expression as PrefixExpression).operator.lexeme, '!');
+    expression = expression.operand;
+    expect(expression, isAwaitExpression);
+  }
+
+  void test_parseAwaitExpression_inSync_v3_49116() {
+    createParser('m() { print(await returnsFuture()); }');
+    var method = parser.parseClassMember('C') as MethodDeclaration;
+    expect(method, isNotNull);
+    listener.assertErrors([
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 12, 5),
+    ]);
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isExpressionStatement);
+    Expression expression = (statement as ExpressionStatement).expression;
+    expect(expression, isMethodInvocation);
+    expression = (expression as MethodInvocation).argumentList.arguments.single;
+    expect(expression, isAwaitExpression);
+  }
+
+  void test_parseAwaitExpression_inSync_v4_49116() {
+    createParser('''m() {
+      xor(await returnsFuture(), await returnsFuture(), await returnsFuture());
+    }''');
+    var method = parser.parseClassMember('C') as MethodDeclaration;
+    expect(method, isNotNull);
+    listener.assertErrors([
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 16, 5),
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 39, 5),
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 62, 5),
+    ]);
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isExpressionStatement);
+    Expression expression = (statement as ExpressionStatement).expression;
+    expect(expression, isMethodInvocation);
+    expect((expression as MethodInvocation).argumentList.arguments.length, 3);
+    expect(expression.argumentList.arguments[0], isAwaitExpression);
+    expect(expression.argumentList.arguments[1], isAwaitExpression);
+    expect(expression.argumentList.arguments[2], isAwaitExpression);
+  }
+
+  void test_parseAwaitExpression_inSync_v5_49116() {
+    createParser('''m() {
+      await returnsFuture() ^ await returnsFuture();
+    }''');
+    var method = parser.parseClassMember('C') as MethodDeclaration;
+    expect(method, isNotNull);
+    listener.assertErrors([
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 12, 5),
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 36, 5),
+    ]);
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isExpressionStatement);
+    Expression expression = (statement as ExpressionStatement).expression;
+    expect(expression, isBinaryExpression);
+    expect((expression as BinaryExpression).leftOperand, isAwaitExpression);
+    expect(expression.rightOperand, isAwaitExpression);
+    expect(expression.operator.lexeme, '^');
+  }
+
+  void test_parseAwaitExpression_inSync_v6_49116() {
+    createParser('''m() {
+      print(await returnsFuture() ^ await returnsFuture());
+    }''');
+    var method = parser.parseClassMember('C') as MethodDeclaration;
+    expect(method, isNotNull);
+    listener.assertErrors([
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 18, 5),
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 42, 5),
+    ]);
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isExpressionStatement);
+    Expression expression = (statement as ExpressionStatement).expression;
+    expect(expression, isMethodInvocation);
+    expression = (expression as MethodInvocation).argumentList.arguments.single;
+    expect(expression, isBinaryExpression);
+    expect((expression as BinaryExpression).leftOperand, isAwaitExpression);
+    expect(expression.rightOperand, isAwaitExpression);
+    expect(expression.operator.lexeme, '^');
   }
 
   void test_parseClassMember_constructor_initializers_conditional() {

pkg/analyzer/test/generated/parser_fasta_listener.dart

@@ -1002,7 +1002,8 @@ class ForwardingTestListener extends ForwardingListener {
   @override
   void endInvalidAwaitExpression(
       Token beginToken, Token endToken, MessageCode errorCode) {
-    end('InvalidAwaitExpression');
+    // endInvalidAwaitExpression is started by beginAwaitExpression
+    end('AwaitExpression');
     super.endInvalidAwaitExpression(beginToken, endToken, errorCode);
   }
 

pkg/analyzer/test/src/diagnostics/await_in_wrong_context_test.dart

@@ -15,11 +15,7 @@ main() {
 
 @reflectiveTest
 class AwaitInWrongContextTest extends PubPackageResolutionTest {
-  @failingTest
   test_sync() async {
-    // This test requires better error recovery than we currently have. In
-    // particular, we need to be able to distinguish between an await expression
-    // in the wrong context, and the use of 'await' as an identifier.
     await assertErrorsInCode(r'''
 f(x) {
   return await x;
@@ -30,9 +26,6 @@ f(x) {
   }
 
   test_syncStar() async {
-    // This test requires better error recovery than we currently have. In
-    // particular, we need to be able to distinguish between an await expression
-    // in the wrong context, and the use of 'await' as an identifier.
     await assertErrorsInCode(r'''
 f(x) sync* {
   yield await x;

pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect

@@ -90,15 +90,15 @@ parseUnit(Future)
           parseStatement({)
             parseStatementX({)
               inPlainSync()
-              looksLikeAwaitExpression({)
-                looksLikeExpression(await)
+              looksLikeAwaitExpression({, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement({)
                 parseExpression({)
                   parsePrecedenceExpression({, 1, true)
                     parseUnaryExpression({, true)
                       inPlainSync()
-                      looksLikeAwaitExpression({)
-                        looksLikeExpression(await)
+                      looksLikeAwaitExpression({, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression({, true)
                         listener: beginAwaitExpression(await)
                         parsePrecedenceExpression(await, 16, true)

pkg/front_end/parser_testcases/error_recovery/issue_49116.dart

@@ -0,0 +1,51 @@
+Future<bool> returnsFuture() => new Future.value(true);
+
+// Notice the missing async marker.
+void foo() {
+  await returnsFuture();
+  if (await returnsFuture()) {}
+  else if (!await returnsFuture()) {}
+  print(await returnsFuture());
+  xor(await returnsFuture(), await returnsFuture(), await returnsFuture());
+  await returnsFuture() ^ await returnsFuture();
+  print(await returnsFuture() ^ await returnsFuture());
+  await returnsFuture() + await returnsFuture();
+  print(await returnsFuture() + await returnsFuture());
+  await returnsFuture() - await returnsFuture();
+  print(await returnsFuture() - await returnsFuture());
+  !await returnsFuture() ^ !await returnsFuture();
+  print(!await returnsFuture() ^ !await returnsFuture());
+
+  var f = returnsFuture();
+  await f; // valid variable declaration.
+  if (await f) {}
+  else if (!await f) {}
+  print(await f);
+  xor(await f, await f, await f);
+  await f ^ await f;
+  print(await f ^ await f);
+  await f + await f;
+  print(await f + await f);
+  await f - await f;
+  print(await f - await f);
+  !await f ^ !await f;
+  print(!await f ^ !await f);
+
+  // Valid:
+  await x; // Valid.
+  await y, z; // Valid.
+  await x2 = await; // Valid.
+  await y2 = await, z2 = await; // Valid.
+  await foo(int bar) { // Valid.
+    return new await(); // Valid.
+  } // Valid.
+  await bar(await baz, await baz2, await baz3) { // Valid.
+    return baz; // Valid.
+  } // Valid.
+}
+
+bool xor(bool a, bool b, bool c) {
+  return b ^ b ^ c;
+}
+
+class await {}