diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
index 755066d4..5e18cbd 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
@@ -5015,7 +5015,7 @@
           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 @@
       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 @@
     // 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 @@
 
   /// 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 @@
       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 @@
 
   /// 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 @@
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.
 typedef _MessageWithArgument<T> = codes.Message Function(T);
+
+enum AwaitOrYieldContext { Statement, UnaryExpression }
diff --git a/pkg/analyzer/test/generated/class_member_parser_test.dart b/pkg/analyzer/test/generated/class_member_parser_test.dart
index 53ff979..7b39f70 100644
--- a/pkg/analyzer/test/generated/class_member_parser_test.dart
+++ b/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,8 +144,8 @@
     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);
@@ -152,6 +153,134 @@
     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() {
diff --git a/pkg/analyzer/test/generated/parser_fasta_listener.dart b/pkg/analyzer/test/generated/parser_fasta_listener.dart
index a9606e7..c5ebdac 100644
--- a/pkg/analyzer/test/generated/parser_fasta_listener.dart
+++ b/pkg/analyzer/test/generated/parser_fasta_listener.dart
@@ -1002,7 +1002,8 @@
   @override
   void endInvalidAwaitExpression(
       Token beginToken, Token endToken, MessageCode errorCode) {
-    end('InvalidAwaitExpression');
+    // endInvalidAwaitExpression is started by beginAwaitExpression
+    end('AwaitExpression');
     super.endInvalidAwaitExpression(beginToken, endToken, errorCode);
   }
 
diff --git a/pkg/analyzer/test/src/diagnostics/await_in_wrong_context_test.dart b/pkg/analyzer/test/src/diagnostics/await_in_wrong_context_test.dart
index e99bf8e..b47706d 100644
--- a/pkg/analyzer/test/src/diagnostics/await_in_wrong_context_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/await_in_wrong_context_test.dart
@@ -15,11 +15,7 @@
 
 @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 @@
   }
 
   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;
diff --git a/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
index 79c6a54..4aa4e44 100644
--- a/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
@@ -90,15 +90,15 @@
           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)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart
new file mode 100644
index 0000000..8465f8a
--- /dev/null
+++ b/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 {}
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.expect b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.expect
new file mode 100644
index 0000000..931a453
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.expect
@@ -0,0 +1,978 @@
+Problems reported:
+
+parser/error_recovery/issue_49116:5:3: 'await' can only be used in 'async' or 'async*' methods.
+  await returnsFuture();
+  ^^^^^
+
+parser/error_recovery/issue_49116:6:7: 'await' can only be used in 'async' or 'async*' methods.
+  if (await returnsFuture()) {}
+      ^^^^^
+
+parser/error_recovery/issue_49116:7:13: 'await' can only be used in 'async' or 'async*' methods.
+  else if (!await returnsFuture()) {}
+            ^^^^^
+
+parser/error_recovery/issue_49116:8:9: 'await' can only be used in 'async' or 'async*' methods.
+  print(await returnsFuture());
+        ^^^^^
+
+parser/error_recovery/issue_49116:9:7: 'await' can only be used in 'async' or 'async*' methods.
+  xor(await returnsFuture(), await returnsFuture(), await returnsFuture());
+      ^^^^^
+
+parser/error_recovery/issue_49116:9:30: 'await' can only be used in 'async' or 'async*' methods.
+  xor(await returnsFuture(), await returnsFuture(), await returnsFuture());
+                             ^^^^^
+
+parser/error_recovery/issue_49116:9:53: 'await' can only be used in 'async' or 'async*' methods.
+  xor(await returnsFuture(), await returnsFuture(), await returnsFuture());
+                                                    ^^^^^
+
+parser/error_recovery/issue_49116:10:3: 'await' can only be used in 'async' or 'async*' methods.
+  await returnsFuture() ^ await returnsFuture();
+  ^^^^^
+
+parser/error_recovery/issue_49116:10:27: 'await' can only be used in 'async' or 'async*' methods.
+  await returnsFuture() ^ await returnsFuture();
+                          ^^^^^
+
+parser/error_recovery/issue_49116:11:9: 'await' can only be used in 'async' or 'async*' methods.
+  print(await returnsFuture() ^ await returnsFuture());
+        ^^^^^
+
+parser/error_recovery/issue_49116:11:33: 'await' can only be used in 'async' or 'async*' methods.
+  print(await returnsFuture() ^ await returnsFuture());
+                                ^^^^^
+
+parser/error_recovery/issue_49116:12:3: 'await' can only be used in 'async' or 'async*' methods.
+  await returnsFuture() + await returnsFuture();
+  ^^^^^
+
+parser/error_recovery/issue_49116:12:27: 'await' can only be used in 'async' or 'async*' methods.
+  await returnsFuture() + await returnsFuture();
+                          ^^^^^
+
+parser/error_recovery/issue_49116:13:9: 'await' can only be used in 'async' or 'async*' methods.
+  print(await returnsFuture() + await returnsFuture());
+        ^^^^^
+
+parser/error_recovery/issue_49116:13:33: 'await' can only be used in 'async' or 'async*' methods.
+  print(await returnsFuture() + await returnsFuture());
+                                ^^^^^
+
+parser/error_recovery/issue_49116:14:3: 'await' can only be used in 'async' or 'async*' methods.
+  await returnsFuture() - await returnsFuture();
+  ^^^^^
+
+parser/error_recovery/issue_49116:14:27: 'await' can only be used in 'async' or 'async*' methods.
+  await returnsFuture() - await returnsFuture();
+                          ^^^^^
+
+parser/error_recovery/issue_49116:15:9: 'await' can only be used in 'async' or 'async*' methods.
+  print(await returnsFuture() - await returnsFuture());
+        ^^^^^
+
+parser/error_recovery/issue_49116:15:33: 'await' can only be used in 'async' or 'async*' methods.
+  print(await returnsFuture() - await returnsFuture());
+                                ^^^^^
+
+parser/error_recovery/issue_49116:16:4: 'await' can only be used in 'async' or 'async*' methods.
+  !await returnsFuture() ^ !await returnsFuture();
+   ^^^^^
+
+parser/error_recovery/issue_49116:16:29: 'await' can only be used in 'async' or 'async*' methods.
+  !await returnsFuture() ^ !await returnsFuture();
+                            ^^^^^
+
+parser/error_recovery/issue_49116:17:10: 'await' can only be used in 'async' or 'async*' methods.
+  print(!await returnsFuture() ^ !await returnsFuture());
+         ^^^^^
+
+parser/error_recovery/issue_49116:17:35: 'await' can only be used in 'async' or 'async*' methods.
+  print(!await returnsFuture() ^ !await returnsFuture());
+                                  ^^^^^
+
+parser/error_recovery/issue_49116:21:7: 'await' can only be used in 'async' or 'async*' methods.
+  if (await f) {}
+      ^^^^^
+
+parser/error_recovery/issue_49116:22:13: 'await' can only be used in 'async' or 'async*' methods.
+  else if (!await f) {}
+            ^^^^^
+
+parser/error_recovery/issue_49116:23:9: 'await' can only be used in 'async' or 'async*' methods.
+  print(await f);
+        ^^^^^
+
+parser/error_recovery/issue_49116:24:7: 'await' can only be used in 'async' or 'async*' methods.
+  xor(await f, await f, await f);
+      ^^^^^
+
+parser/error_recovery/issue_49116:24:16: 'await' can only be used in 'async' or 'async*' methods.
+  xor(await f, await f, await f);
+               ^^^^^
+
+parser/error_recovery/issue_49116:24:25: 'await' can only be used in 'async' or 'async*' methods.
+  xor(await f, await f, await f);
+                        ^^^^^
+
+parser/error_recovery/issue_49116:25:3: 'await' can only be used in 'async' or 'async*' methods.
+  await f ^ await f;
+  ^^^^^
+
+parser/error_recovery/issue_49116:25:13: 'await' can only be used in 'async' or 'async*' methods.
+  await f ^ await f;
+            ^^^^^
+
+parser/error_recovery/issue_49116:26:9: 'await' can only be used in 'async' or 'async*' methods.
+  print(await f ^ await f);
+        ^^^^^
+
+parser/error_recovery/issue_49116:26:19: 'await' can only be used in 'async' or 'async*' methods.
+  print(await f ^ await f);
+                  ^^^^^
+
+parser/error_recovery/issue_49116:27:3: 'await' can only be used in 'async' or 'async*' methods.
+  await f + await f;
+  ^^^^^
+
+parser/error_recovery/issue_49116:27:13: 'await' can only be used in 'async' or 'async*' methods.
+  await f + await f;
+            ^^^^^
+
+parser/error_recovery/issue_49116:28:9: 'await' can only be used in 'async' or 'async*' methods.
+  print(await f + await f);
+        ^^^^^
+
+parser/error_recovery/issue_49116:28:19: 'await' can only be used in 'async' or 'async*' methods.
+  print(await f + await f);
+                  ^^^^^
+
+parser/error_recovery/issue_49116:29:3: 'await' can only be used in 'async' or 'async*' methods.
+  await f - await f;
+  ^^^^^
+
+parser/error_recovery/issue_49116:29:13: 'await' can only be used in 'async' or 'async*' methods.
+  await f - await f;
+            ^^^^^
+
+parser/error_recovery/issue_49116:30:9: 'await' can only be used in 'async' or 'async*' methods.
+  print(await f - await f);
+        ^^^^^
+
+parser/error_recovery/issue_49116:30:19: 'await' can only be used in 'async' or 'async*' methods.
+  print(await f - await f);
+                  ^^^^^
+
+parser/error_recovery/issue_49116:31:4: 'await' can only be used in 'async' or 'async*' methods.
+  !await f ^ !await f;
+   ^^^^^
+
+parser/error_recovery/issue_49116:31:15: 'await' can only be used in 'async' or 'async*' methods.
+  !await f ^ !await f;
+              ^^^^^
+
+parser/error_recovery/issue_49116:32:10: 'await' can only be used in 'async' or 'async*' methods.
+  print(!await f ^ !await f);
+         ^^^^^
+
+parser/error_recovery/issue_49116:32:21: 'await' can only be used in 'async' or 'async*' methods.
+  print(!await f ^ !await f);
+                    ^^^^^
+
+beginCompilationUnit(Future)
+  beginMetadataStar(Future)
+  endMetadataStar(0)
+  beginTopLevelMember(Future)
+    beginTopLevelMethod(, null, null)
+      handleIdentifier(Future, typeReference)
+      beginTypeArguments(<)
+        handleIdentifier(bool, typeReference)
+        handleNoTypeArguments(>)
+        handleType(bool, null)
+      endTypeArguments(1, <, >)
+      handleType(Future, null)
+      handleIdentifier(returnsFuture, topLevelFunctionDeclaration)
+      handleNoTypeVariables(()
+      beginFormalParameters((, MemberKind.TopLevelMethod)
+      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+      handleAsyncModifier(null, null)
+      beginNewExpression(new)
+        handleIdentifier(Future, constructorReference)
+        beginConstructorReference(Future)
+          handleIdentifier(value, constructorReferenceContinuation)
+          handleQualified(.)
+          handleNoTypeArguments(()
+          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+        endConstructorReference(Future, null, (, ConstructorReferenceContext.New)
+        beginArguments(()
+          handleLiteralBool(true)
+        endArguments(1, (, ))
+      endNewExpression(new)
+      handleExpressionFunctionBody(=>, ;)
+    endTopLevelMethod(Future, null, ;)
+  endTopLevelDeclaration(void)
+  beginMetadataStar(void)
+  endMetadataStar(0)
+  beginTopLevelMember(void)
+    beginTopLevelMethod(;, null, null)
+      handleVoidKeyword(void)
+      handleIdentifier(foo, topLevelFunctionDeclaration)
+      handleNoTypeVariables(()
+      beginFormalParameters((, MemberKind.TopLevelMethod)
+      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+      handleAsyncModifier(null, null)
+      beginBlockFunctionBody({)
+        beginAwaitExpression(await)
+          handleIdentifier(returnsFuture, expression)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(returnsFuture, ;)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+        handleExpressionStatement(;)
+        beginIfStatement(if)
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ))
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ), AwaitNotAsync)
+          handleParenthesizedCondition(()
+          beginThenStatement({)
+            beginBlock({, BlockKind(statement))
+            endBlock(0, {, }, BlockKind(statement))
+          endThenStatement(})
+          beginElseStatement(else)
+            beginIfStatement(if)
+              beginAwaitExpression(await)
+                handleIdentifier(returnsFuture, expression)
+                handleNoTypeArguments(()
+                beginArguments(()
+                endArguments(0, (, ))
+                handleSend(returnsFuture, ))
+                handleRecoverableError(AwaitNotAsync, await, await)
+              endInvalidAwaitExpression(await, ), AwaitNotAsync)
+              handleUnaryPrefixExpression(!)
+              handleParenthesizedCondition(()
+              beginThenStatement({)
+                beginBlock({, BlockKind(statement))
+                endBlock(0, {, }, BlockKind(statement))
+              endThenStatement(})
+            endIfStatement(if, null)
+          endElseStatement(else)
+        endIfStatement(if, else)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ))
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ), AwaitNotAsync)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        handleIdentifier(xor, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ,)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ,, AwaitNotAsync)
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ,)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ,, AwaitNotAsync)
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ))
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ), AwaitNotAsync)
+        endArguments(3, (, ))
+        handleSend(xor, ;)
+        handleExpressionStatement(;)
+        beginAwaitExpression(await)
+          handleIdentifier(returnsFuture, expression)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(returnsFuture, ^)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+        beginBinaryExpression(^)
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ;)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+        endBinaryExpression(^)
+        handleExpressionStatement(;)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ^)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+          beginBinaryExpression(^)
+            beginAwaitExpression(await)
+              handleIdentifier(returnsFuture, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+              endArguments(0, (, ))
+              handleSend(returnsFuture, ))
+              handleRecoverableError(AwaitNotAsync, await, await)
+            endInvalidAwaitExpression(await, ), AwaitNotAsync)
+          endBinaryExpression(^)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        beginAwaitExpression(await)
+          handleIdentifier(returnsFuture, expression)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(returnsFuture, +)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, +, AwaitNotAsync)
+        beginBinaryExpression(+)
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ;)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+        endBinaryExpression(+)
+        handleExpressionStatement(;)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, +)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, +, AwaitNotAsync)
+          beginBinaryExpression(+)
+            beginAwaitExpression(await)
+              handleIdentifier(returnsFuture, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+              endArguments(0, (, ))
+              handleSend(returnsFuture, ))
+              handleRecoverableError(AwaitNotAsync, await, await)
+            endInvalidAwaitExpression(await, ), AwaitNotAsync)
+          endBinaryExpression(+)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        beginAwaitExpression(await)
+          handleIdentifier(returnsFuture, expression)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(returnsFuture, -)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, -, AwaitNotAsync)
+        beginBinaryExpression(-)
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ;)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+        endBinaryExpression(-)
+        handleExpressionStatement(;)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, -)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, -, AwaitNotAsync)
+          beginBinaryExpression(-)
+            beginAwaitExpression(await)
+              handleIdentifier(returnsFuture, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+              endArguments(0, (, ))
+              handleSend(returnsFuture, ))
+              handleRecoverableError(AwaitNotAsync, await, await)
+            endInvalidAwaitExpression(await, ), AwaitNotAsync)
+          endBinaryExpression(-)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        beginAwaitExpression(await)
+          handleIdentifier(returnsFuture, expression)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(returnsFuture, ^)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+        handleUnaryPrefixExpression(!)
+        beginBinaryExpression(^)
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ;)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+          handleUnaryPrefixExpression(!)
+        endBinaryExpression(^)
+        handleExpressionStatement(;)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(returnsFuture, expression)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(returnsFuture, ^)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+          handleUnaryPrefixExpression(!)
+          beginBinaryExpression(^)
+            beginAwaitExpression(await)
+              handleIdentifier(returnsFuture, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+              endArguments(0, (, ))
+              handleSend(returnsFuture, ))
+              handleRecoverableError(AwaitNotAsync, await, await)
+            endInvalidAwaitExpression(await, ), AwaitNotAsync)
+            handleUnaryPrefixExpression(!)
+          endBinaryExpression(^)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        beginMetadataStar(var)
+        endMetadataStar(0)
+        handleNoType(var)
+        beginVariablesDeclaration(f, null, var)
+          handleIdentifier(f, localVariableDeclaration)
+          beginInitializedIdentifier(f)
+            beginVariableInitializer(=)
+              handleIdentifier(returnsFuture, expression)
+              handleNoTypeArguments(()
+              beginArguments(()
+              endArguments(0, (, ))
+              handleSend(returnsFuture, ;)
+            endVariableInitializer(=)
+          endInitializedIdentifier(f)
+        endVariablesDeclaration(1, ;)
+        beginMetadataStar(await)
+        endMetadataStar(0)
+        handleIdentifier(await, typeReference)
+        handleNoTypeArguments(f)
+        handleType(await, null)
+        beginVariablesDeclaration(f, null, null)
+          handleIdentifier(f, localVariableDeclaration)
+          beginInitializedIdentifier(f)
+            handleNoVariableInitializer(f)
+          endInitializedIdentifier(f)
+        endVariablesDeclaration(1, ;)
+        beginIfStatement(if)
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments())
+            handleNoArguments())
+            handleSend(f, ))
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ), AwaitNotAsync)
+          handleParenthesizedCondition(()
+          beginThenStatement({)
+            beginBlock({, BlockKind(statement))
+            endBlock(0, {, }, BlockKind(statement))
+          endThenStatement(})
+          beginElseStatement(else)
+            beginIfStatement(if)
+              beginAwaitExpression(await)
+                handleIdentifier(f, expression)
+                handleNoTypeArguments())
+                handleNoArguments())
+                handleSend(f, ))
+                handleRecoverableError(AwaitNotAsync, await, await)
+              endInvalidAwaitExpression(await, ), AwaitNotAsync)
+              handleUnaryPrefixExpression(!)
+              handleParenthesizedCondition(()
+              beginThenStatement({)
+                beginBlock({, BlockKind(statement))
+                endBlock(0, {, }, BlockKind(statement))
+              endThenStatement(})
+            endIfStatement(if, null)
+          endElseStatement(else)
+        endIfStatement(if, else)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments())
+            handleNoArguments())
+            handleSend(f, ))
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ), AwaitNotAsync)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        handleIdentifier(xor, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(f, ,)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ,, AwaitNotAsync)
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(f, ,)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ,, AwaitNotAsync)
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments())
+            handleNoArguments())
+            handleSend(f, ))
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ), AwaitNotAsync)
+        endArguments(3, (, ))
+        handleSend(xor, ;)
+        handleExpressionStatement(;)
+        beginAwaitExpression(await)
+          handleIdentifier(f, expression)
+          handleNoTypeArguments(^)
+          handleNoArguments(^)
+          handleSend(f, ^)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+        beginBinaryExpression(^)
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(;)
+            handleNoArguments(;)
+            handleSend(f, ;)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+        endBinaryExpression(^)
+        handleExpressionStatement(;)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(^)
+            handleNoArguments(^)
+            handleSend(f, ^)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+          beginBinaryExpression(^)
+            beginAwaitExpression(await)
+              handleIdentifier(f, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(f, ))
+              handleRecoverableError(AwaitNotAsync, await, await)
+            endInvalidAwaitExpression(await, ), AwaitNotAsync)
+          endBinaryExpression(^)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        beginAwaitExpression(await)
+          handleIdentifier(f, expression)
+          handleNoTypeArguments(+)
+          handleNoArguments(+)
+          handleSend(f, +)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, +, AwaitNotAsync)
+        beginBinaryExpression(+)
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(;)
+            handleNoArguments(;)
+            handleSend(f, ;)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+        endBinaryExpression(+)
+        handleExpressionStatement(;)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(+)
+            handleNoArguments(+)
+            handleSend(f, +)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, +, AwaitNotAsync)
+          beginBinaryExpression(+)
+            beginAwaitExpression(await)
+              handleIdentifier(f, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(f, ))
+              handleRecoverableError(AwaitNotAsync, await, await)
+            endInvalidAwaitExpression(await, ), AwaitNotAsync)
+          endBinaryExpression(+)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        beginAwaitExpression(await)
+          handleIdentifier(f, expression)
+          handleNoTypeArguments(-)
+          handleNoArguments(-)
+          handleSend(f, -)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, -, AwaitNotAsync)
+        beginBinaryExpression(-)
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(;)
+            handleNoArguments(;)
+            handleSend(f, ;)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+        endBinaryExpression(-)
+        handleExpressionStatement(;)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(-)
+            handleNoArguments(-)
+            handleSend(f, -)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, -, AwaitNotAsync)
+          beginBinaryExpression(-)
+            beginAwaitExpression(await)
+              handleIdentifier(f, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(f, ))
+              handleRecoverableError(AwaitNotAsync, await, await)
+            endInvalidAwaitExpression(await, ), AwaitNotAsync)
+          endBinaryExpression(-)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        beginAwaitExpression(await)
+          handleIdentifier(f, expression)
+          handleNoTypeArguments(^)
+          handleNoArguments(^)
+          handleSend(f, ^)
+          handleRecoverableError(AwaitNotAsync, await, await)
+        endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+        handleUnaryPrefixExpression(!)
+        beginBinaryExpression(^)
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(;)
+            handleNoArguments(;)
+            handleSend(f, ;)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+          handleUnaryPrefixExpression(!)
+        endBinaryExpression(^)
+        handleExpressionStatement(;)
+        handleIdentifier(print, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          beginAwaitExpression(await)
+            handleIdentifier(f, expression)
+            handleNoTypeArguments(^)
+            handleNoArguments(^)
+            handleSend(f, ^)
+            handleRecoverableError(AwaitNotAsync, await, await)
+          endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+          handleUnaryPrefixExpression(!)
+          beginBinaryExpression(^)
+            beginAwaitExpression(await)
+              handleIdentifier(f, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(f, ))
+              handleRecoverableError(AwaitNotAsync, await, await)
+            endInvalidAwaitExpression(await, ), AwaitNotAsync)
+            handleUnaryPrefixExpression(!)
+          endBinaryExpression(^)
+        endArguments(1, (, ))
+        handleSend(print, ;)
+        handleExpressionStatement(;)
+        beginMetadataStar(await)
+        endMetadataStar(0)
+        handleIdentifier(await, typeReference)
+        handleNoTypeArguments(x)
+        handleType(await, null)
+        beginVariablesDeclaration(x, null, null)
+          handleIdentifier(x, localVariableDeclaration)
+          beginInitializedIdentifier(x)
+            handleNoVariableInitializer(x)
+          endInitializedIdentifier(x)
+        endVariablesDeclaration(1, ;)
+        beginMetadataStar(await)
+        endMetadataStar(0)
+        handleIdentifier(await, typeReference)
+        handleNoTypeArguments(y)
+        handleType(await, null)
+        beginVariablesDeclaration(y, null, null)
+          handleIdentifier(y, localVariableDeclaration)
+          beginInitializedIdentifier(y)
+            handleNoVariableInitializer(y)
+          endInitializedIdentifier(y)
+          handleIdentifier(z, localVariableDeclaration)
+          beginInitializedIdentifier(z)
+            handleNoVariableInitializer(z)
+          endInitializedIdentifier(z)
+        endVariablesDeclaration(2, ;)
+        beginMetadataStar(await)
+        endMetadataStar(0)
+        handleIdentifier(await, typeReference)
+        handleNoTypeArguments(x2)
+        handleType(await, null)
+        beginVariablesDeclaration(x2, null, null)
+          handleIdentifier(x2, localVariableDeclaration)
+          beginInitializedIdentifier(x2)
+            beginVariableInitializer(=)
+              handleIdentifier(await, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(await, ;)
+            endVariableInitializer(=)
+          endInitializedIdentifier(x2)
+        endVariablesDeclaration(1, ;)
+        beginMetadataStar(await)
+        endMetadataStar(0)
+        handleIdentifier(await, typeReference)
+        handleNoTypeArguments(y2)
+        handleType(await, null)
+        beginVariablesDeclaration(y2, null, null)
+          handleIdentifier(y2, localVariableDeclaration)
+          beginInitializedIdentifier(y2)
+            beginVariableInitializer(=)
+              handleIdentifier(await, expression)
+              handleNoTypeArguments(,)
+              handleNoArguments(,)
+              handleSend(await, ,)
+            endVariableInitializer(=)
+          endInitializedIdentifier(y2)
+          handleIdentifier(z2, localVariableDeclaration)
+          beginInitializedIdentifier(z2)
+            beginVariableInitializer(=)
+              handleIdentifier(await, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(await, ;)
+            endVariableInitializer(=)
+          endInitializedIdentifier(z2)
+        endVariablesDeclaration(2, ;)
+        beginMetadataStar(await)
+        endMetadataStar(0)
+        handleNoTypeVariables(()
+        beginLocalFunctionDeclaration(await)
+          handleIdentifier(await, typeReference)
+          handleNoTypeArguments(foo)
+          handleType(await, null)
+          beginFunctionName(foo)
+            handleIdentifier(foo, localFunctionDeclaration)
+          endFunctionName(await, ()
+          beginFormalParameters((, MemberKind.Local)
+            beginMetadataStar(int)
+            endMetadataStar(0)
+            beginFormalParameter(int, MemberKind.Local, null, null, null)
+              handleIdentifier(int, typeReference)
+              handleNoTypeArguments(bar)
+              handleType(int, null)
+              handleIdentifier(bar, formalParameterDeclaration)
+              handleFormalParameterWithoutValue())
+            endFormalParameter(null, null, null, bar, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+          endFormalParameters(1, (, ), MemberKind.Local)
+          handleNoInitializers()
+          handleAsyncModifier(null, null)
+          beginBlockFunctionBody({)
+            beginReturnStatement(return)
+              beginNewExpression(new)
+                handleIdentifier(await, constructorReference)
+                beginConstructorReference(await)
+                  handleNoTypeArguments(()
+                  handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                endConstructorReference(await, null, (, ConstructorReferenceContext.New)
+                beginArguments(()
+                endArguments(0, (, ))
+              endNewExpression(new)
+            endReturnStatement(true, return, ;)
+          endBlockFunctionBody(1, {, })
+        endLocalFunctionDeclaration(})
+        beginMetadataStar(await)
+        endMetadataStar(0)
+        handleNoTypeVariables(()
+        beginLocalFunctionDeclaration(await)
+          handleIdentifier(await, typeReference)
+          handleNoTypeArguments(bar)
+          handleType(await, null)
+          beginFunctionName(bar)
+            handleIdentifier(bar, localFunctionDeclaration)
+          endFunctionName(await, ()
+          beginFormalParameters((, MemberKind.Local)
+            beginMetadataStar(await)
+            endMetadataStar(0)
+            beginFormalParameter(await, MemberKind.Local, null, null, null)
+              handleIdentifier(await, typeReference)
+              handleNoTypeArguments(baz)
+              handleType(await, null)
+              handleIdentifier(baz, formalParameterDeclaration)
+              handleFormalParameterWithoutValue(,)
+            endFormalParameter(null, null, null, baz, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+            beginMetadataStar(await)
+            endMetadataStar(0)
+            beginFormalParameter(await, MemberKind.Local, null, null, null)
+              handleIdentifier(await, typeReference)
+              handleNoTypeArguments(baz2)
+              handleType(await, null)
+              handleIdentifier(baz2, formalParameterDeclaration)
+              handleFormalParameterWithoutValue(,)
+            endFormalParameter(null, null, null, baz2, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+            beginMetadataStar(await)
+            endMetadataStar(0)
+            beginFormalParameter(await, MemberKind.Local, null, null, null)
+              handleIdentifier(await, typeReference)
+              handleNoTypeArguments(baz3)
+              handleType(await, null)
+              handleIdentifier(baz3, formalParameterDeclaration)
+              handleFormalParameterWithoutValue())
+            endFormalParameter(null, null, null, baz3, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+          endFormalParameters(3, (, ), MemberKind.Local)
+          handleNoInitializers()
+          handleAsyncModifier(null, null)
+          beginBlockFunctionBody({)
+            beginReturnStatement(return)
+              handleIdentifier(baz, expression)
+              handleNoTypeArguments(;)
+              handleNoArguments(;)
+              handleSend(baz, ;)
+            endReturnStatement(true, return, ;)
+          endBlockFunctionBody(1, {, })
+        endLocalFunctionDeclaration(})
+      endBlockFunctionBody(31, {, })
+    endTopLevelMethod(void, null, })
+  endTopLevelDeclaration(bool)
+  beginMetadataStar(bool)
+  endMetadataStar(0)
+  beginTopLevelMember(bool)
+    beginTopLevelMethod(}, null, null)
+      handleIdentifier(bool, typeReference)
+      handleNoTypeArguments(xor)
+      handleType(bool, null)
+      handleIdentifier(xor, topLevelFunctionDeclaration)
+      handleNoTypeVariables(()
+      beginFormalParameters((, MemberKind.TopLevelMethod)
+        beginMetadataStar(bool)
+        endMetadataStar(0)
+        beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
+          handleIdentifier(bool, typeReference)
+          handleNoTypeArguments(a)
+          handleType(bool, null)
+          handleIdentifier(a, formalParameterDeclaration)
+          handleFormalParameterWithoutValue(,)
+        endFormalParameter(null, null, null, a, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+        beginMetadataStar(bool)
+        endMetadataStar(0)
+        beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
+          handleIdentifier(bool, typeReference)
+          handleNoTypeArguments(b)
+          handleType(bool, null)
+          handleIdentifier(b, formalParameterDeclaration)
+          handleFormalParameterWithoutValue(,)
+        endFormalParameter(null, null, null, b, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+        beginMetadataStar(bool)
+        endMetadataStar(0)
+        beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
+          handleIdentifier(bool, typeReference)
+          handleNoTypeArguments(c)
+          handleType(bool, null)
+          handleIdentifier(c, formalParameterDeclaration)
+          handleFormalParameterWithoutValue())
+        endFormalParameter(null, null, null, c, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+      endFormalParameters(3, (, ), MemberKind.TopLevelMethod)
+      handleAsyncModifier(null, null)
+      beginBlockFunctionBody({)
+        beginReturnStatement(return)
+          handleIdentifier(b, expression)
+          handleNoTypeArguments(^)
+          handleNoArguments(^)
+          handleSend(b, ^)
+          beginBinaryExpression(^)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(^)
+            handleNoArguments(^)
+            handleSend(b, ^)
+          endBinaryExpression(^)
+          beginBinaryExpression(^)
+            handleIdentifier(c, expression)
+            handleNoTypeArguments(;)
+            handleNoArguments(;)
+            handleSend(c, ;)
+          endBinaryExpression(^)
+        endReturnStatement(true, return, ;)
+      endBlockFunctionBody(1, {, })
+    endTopLevelMethod(bool, null, })
+  endTopLevelDeclaration(class)
+  beginMetadataStar(class)
+  endMetadataStar(0)
+  beginClassOrMixinOrNamedMixinApplicationPrelude(class)
+    handleIdentifier(await, classOrMixinDeclaration)
+    handleNoTypeVariables({)
+    beginClassDeclaration(class, null, null, null, await)
+      handleNoType(await)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleImplements(null, 0)
+      handleClassHeader(class, class, null)
+      beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
+      endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
+    endClassDeclaration(class, })
+  endTopLevelDeclaration()
+endCompilationUnit(4, )
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.intertwined.expect
new file mode 100644
index 0000000..bb92ce2
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.intertwined.expect
@@ -0,0 +1,2318 @@
+parseUnit(Future)
+  skipErrorTokens(Future)
+  listener: beginCompilationUnit(Future)
+  syntheticPreviousToken(Future)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(Future)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl()
+      listener: beginTopLevelMember(Future)
+      parseTopLevelMethod(, null, null, , Instance of 'SimpleTypeWith1Argument', null, returnsFuture, false)
+        listener: beginTopLevelMethod(, null, null)
+        listener: handleIdentifier(Future, typeReference)
+        listener: beginTypeArguments(<)
+        listener: handleIdentifier(bool, typeReference)
+        listener: handleNoTypeArguments(>)
+        listener: handleType(bool, null)
+        listener: endTypeArguments(1, <, >)
+        listener: handleType(Future, null)
+        ensureIdentifierPotentiallyRecovered(>, topLevelFunctionDeclaration, false)
+          listener: handleIdentifier(returnsFuture, topLevelFunctionDeclaration)
+        parseMethodTypeVar(returnsFuture)
+          listener: handleNoTypeVariables(()
+        parseGetterOrFormalParameters(returnsFuture, returnsFuture, false, MemberKind.TopLevelMethod)
+          parseFormalParameters(returnsFuture, MemberKind.TopLevelMethod)
+            parseFormalParametersRest((, MemberKind.TopLevelMethod)
+              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
+              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+        parseAsyncModifierOpt())
+          listener: handleAsyncModifier(null, null)
+          inPlainSync()
+        parseFunctionBody(), false, false)
+          parseExpressionFunctionBody(=>, false)
+            parseExpression(=>)
+              parsePrecedenceExpression(=>, 1, true)
+                parseUnaryExpression(=>, true)
+                  parsePrimary(=>, expression)
+                    parseNewExpression(=>)
+                      isNextIdentifier(new)
+                      listener: beginNewExpression(new)
+                      parseConstructorReference(new, ConstructorReferenceContext.New, null)
+                        ensureIdentifier(new, constructorReference)
+                          listener: handleIdentifier(Future, constructorReference)
+                        listener: beginConstructorReference(Future)
+                        parseQualifiedRestOpt(Future, constructorReferenceContinuation)
+                          parseQualifiedRest(Future, constructorReferenceContinuation)
+                            ensureIdentifier(., constructorReferenceContinuation)
+                              listener: handleIdentifier(value, constructorReferenceContinuation)
+                            listener: handleQualified(.)
+                        listener: handleNoTypeArguments(()
+                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        listener: endConstructorReference(Future, null, (, ConstructorReferenceContext.New)
+                      parseConstructorInvocationArguments(value)
+                        parseArgumentsRest(()
+                          listener: beginArguments(()
+                          parseExpression(()
+                            parsePrecedenceExpression((, 1, true)
+                              parseUnaryExpression((, true)
+                                parsePrimary((, expression)
+                                  parseLiteralBool(()
+                                    listener: handleLiteralBool(true)
+                          listener: endArguments(1, (, ))
+                      listener: endNewExpression(new)
+            ensureSemicolon())
+            listener: handleExpressionFunctionBody(=>, ;)
+            inGenerator()
+        listener: endTopLevelMethod(Future, null, ;)
+  listener: endTopLevelDeclaration(void)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(void)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(void)
+      parseTopLevelMethod(;, null, null, ;, Instance of 'VoidType', null, foo, false)
+        listener: beginTopLevelMethod(;, null, null)
+        listener: handleVoidKeyword(void)
+        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
+          listener: handleIdentifier(foo, topLevelFunctionDeclaration)
+        parseMethodTypeVar(foo)
+          listener: handleNoTypeVariables(()
+        parseGetterOrFormalParameters(foo, foo, false, MemberKind.TopLevelMethod)
+          parseFormalParameters(foo, MemberKind.TopLevelMethod)
+            parseFormalParametersRest((, MemberKind.TopLevelMethod)
+              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
+              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+        parseAsyncModifierOpt())
+          listener: handleAsyncModifier(null, null)
+          inPlainSync()
+        parseFunctionBody(), false, false)
+          listener: beginBlockFunctionBody({)
+          notEofOrValue(}, await)
+          parseStatement({)
+            parseStatementX({)
+              inPlainSync()
+              looksLikeAwaitExpression({, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatement({)
+                parseExpression({)
+                  parsePrecedenceExpression({, 1, true)
+                    parseUnaryExpression({, true)
+                      inPlainSync()
+                      looksLikeAwaitExpression({, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                      parseAwaitExpression({, true)
+                        listener: beginAwaitExpression(await)
+                        parsePrecedenceExpression(await, 16, true)
+                          parseUnaryExpression(await, true)
+                            parsePrimary(await, expression)
+                              parseSendOrFunctionLiteral(await, expression)
+                                looksLikeFunctionBody(;)
+                                parseSend(await, expression)
+                                  isNextIdentifier(await)
+                                  ensureIdentifier(await, expression)
+                                    listener: handleIdentifier(returnsFuture, expression)
+                                  listener: handleNoTypeArguments(()
+                                  parseArgumentsOpt(returnsFuture)
+                                    parseArguments(returnsFuture)
+                                      parseArgumentsRest(()
+                                        listener: beginArguments(()
+                                        listener: endArguments(0, (, ))
+                                  listener: handleSend(returnsFuture, ;)
+                        inAsync()
+                        reportRecoverableError(await, AwaitNotAsync)
+                          listener: handleRecoverableError(AwaitNotAsync, await, await)
+                        listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                ensureSemicolon())
+                listener: handleExpressionStatement(;)
+          notEofOrValue(}, if)
+          parseStatement(;)
+            parseStatementX(;)
+              parseIfStatement(;)
+                listener: beginIfStatement(if)
+                ensureParenthesizedCondition(if)
+                  parseExpressionInParenthesisRest(()
+                    parseExpression(()
+                      parsePrecedenceExpression((, 1, true)
+                        parseUnaryExpression((, true)
+                          inPlainSync()
+                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                          parseAwaitExpression((, true)
+                            listener: beginAwaitExpression(await)
+                            parsePrecedenceExpression(await, 16, true)
+                              parseUnaryExpression(await, true)
+                                parsePrimary(await, expression)
+                                  parseSendOrFunctionLiteral(await, expression)
+                                    looksLikeFunctionBody())
+                                    parseSend(await, expression)
+                                      isNextIdentifier(await)
+                                      ensureIdentifier(await, expression)
+                                        listener: handleIdentifier(returnsFuture, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArgumentsOpt(returnsFuture)
+                                        parseArguments(returnsFuture)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            listener: endArguments(0, (, ))
+                                      listener: handleSend(returnsFuture, ))
+                            inAsync()
+                            reportRecoverableError(await, AwaitNotAsync)
+                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                    ensureCloseParen(), ()
+                  listener: handleParenthesizedCondition(()
+                listener: beginThenStatement({)
+                parseStatement())
+                  parseStatementX())
+                    parseBlock(), BlockKind(statement))
+                      ensureBlock(), null, null)
+                      listener: beginBlock({, BlockKind(statement))
+                      notEofOrValue(}, })
+                      listener: endBlock(0, {, }, BlockKind(statement))
+                listener: endThenStatement(})
+                listener: beginElseStatement(else)
+                parseStatement(else)
+                  parseStatementX(else)
+                    parseIfStatement(else)
+                      listener: beginIfStatement(if)
+                      ensureParenthesizedCondition(if)
+                        parseExpressionInParenthesisRest(()
+                          parseExpression(()
+                            parsePrecedenceExpression((, 1, true)
+                              parseUnaryExpression((, true)
+                                parsePrecedenceExpression(!, 16, true)
+                                  parseUnaryExpression(!, true)
+                                    inPlainSync()
+                                    looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                      looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                    parseAwaitExpression(!, true)
+                                      listener: beginAwaitExpression(await)
+                                      parsePrecedenceExpression(await, 16, true)
+                                        parseUnaryExpression(await, true)
+                                          parsePrimary(await, expression)
+                                            parseSendOrFunctionLiteral(await, expression)
+                                              looksLikeFunctionBody())
+                                              parseSend(await, expression)
+                                                isNextIdentifier(await)
+                                                ensureIdentifier(await, expression)
+                                                  listener: handleIdentifier(returnsFuture, expression)
+                                                listener: handleNoTypeArguments(()
+                                                parseArgumentsOpt(returnsFuture)
+                                                  parseArguments(returnsFuture)
+                                                    parseArgumentsRest(()
+                                                      listener: beginArguments(()
+                                                      listener: endArguments(0, (, ))
+                                                listener: handleSend(returnsFuture, ))
+                                      inAsync()
+                                      reportRecoverableError(await, AwaitNotAsync)
+                                        listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                      listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                listener: handleUnaryPrefixExpression(!)
+                          ensureCloseParen(), ()
+                        listener: handleParenthesizedCondition(()
+                      listener: beginThenStatement({)
+                      parseStatement())
+                        parseStatementX())
+                          parseBlock(), BlockKind(statement))
+                            ensureBlock(), null, null)
+                            listener: beginBlock({, BlockKind(statement))
+                            notEofOrValue(}, })
+                            listener: endBlock(0, {, }, BlockKind(statement))
+                      listener: endThenStatement(})
+                      listener: endIfStatement(if, null)
+                listener: endElseStatement(else)
+                listener: endIfStatement(if, else)
+          notEofOrValue(}, print)
+          parseStatement(})
+            parseStatementX(})
+              parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(})
+                  parseExpression(})
+                    parsePrecedenceExpression(}, 1, true)
+                      parseUnaryExpression(}, true)
+                        parsePrimary(}, expression)
+                          parseSendOrFunctionLiteral(}, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(}, expression)
+                              isNextIdentifier(})
+                              ensureIdentifier(}, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    looksLikeFunctionBody())
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(returnsFuture, expression)
+                                                      listener: handleNoTypeArguments(()
+                                                      parseArgumentsOpt(returnsFuture)
+                                                        parseArguments(returnsFuture)
+                                                          parseArgumentsRest(()
+                                                            listener: beginArguments(()
+                                                            listener: endArguments(0, (, ))
+                                                      listener: handleSend(returnsFuture, ))
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, xor)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(xor)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(xor, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(xor)
+                                parseArguments(xor)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    looksLikeFunctionBody(,)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(returnsFuture, expression)
+                                                      listener: handleNoTypeArguments(()
+                                                      parseArgumentsOpt(returnsFuture)
+                                                        parseArguments(returnsFuture)
+                                                          parseArgumentsRest(()
+                                                            listener: beginArguments(()
+                                                            listener: endArguments(0, (, ))
+                                                      listener: handleSend(returnsFuture, ,)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
+                                    parseExpression(,)
+                                      parsePrecedenceExpression(,, 1, true)
+                                        parseUnaryExpression(,, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression(,, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    looksLikeFunctionBody(,)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(returnsFuture, expression)
+                                                      listener: handleNoTypeArguments(()
+                                                      parseArgumentsOpt(returnsFuture)
+                                                        parseArguments(returnsFuture)
+                                                          parseArgumentsRest(()
+                                                            listener: beginArguments(()
+                                                            listener: endArguments(0, (, ))
+                                                      listener: handleSend(returnsFuture, ,)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
+                                    parseExpression(,)
+                                      parsePrecedenceExpression(,, 1, true)
+                                        parseUnaryExpression(,, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression(,, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    looksLikeFunctionBody())
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(returnsFuture, expression)
+                                                      listener: handleNoTypeArguments(()
+                                                      parseArgumentsOpt(returnsFuture)
+                                                        parseArguments(returnsFuture)
+                                                          parseArgumentsRest(()
+                                                            listener: beginArguments(()
+                                                            listener: endArguments(0, (, ))
+                                                      listener: handleSend(returnsFuture, ))
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                    listener: endArguments(3, (, ))
+                              listener: handleSend(xor, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatement(;)
+                parseExpression(;)
+                  parsePrecedenceExpression(;, 1, true)
+                    parseUnaryExpression(;, true)
+                      inPlainSync()
+                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                      parseAwaitExpression(;, true)
+                        listener: beginAwaitExpression(await)
+                        parsePrecedenceExpression(await, 16, true)
+                          parseUnaryExpression(await, true)
+                            parsePrimary(await, expression)
+                              parseSendOrFunctionLiteral(await, expression)
+                                looksLikeFunctionBody(^)
+                                parseSend(await, expression)
+                                  isNextIdentifier(await)
+                                  ensureIdentifier(await, expression)
+                                    listener: handleIdentifier(returnsFuture, expression)
+                                  listener: handleNoTypeArguments(()
+                                  parseArgumentsOpt(returnsFuture)
+                                    parseArguments(returnsFuture)
+                                      parseArgumentsRest(()
+                                        listener: beginArguments(()
+                                        listener: endArguments(0, (, ))
+                                  listener: handleSend(returnsFuture, ^)
+                        inAsync()
+                        reportRecoverableError(await, AwaitNotAsync)
+                          listener: handleRecoverableError(AwaitNotAsync, await, await)
+                        listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+                    listener: beginBinaryExpression(^)
+                    parsePrecedenceExpression(^, 11, true)
+                      parseUnaryExpression(^, true)
+                        inPlainSync()
+                        looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
+                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                        parseAwaitExpression(^, true)
+                          listener: beginAwaitExpression(await)
+                          parsePrecedenceExpression(await, 16, true)
+                            parseUnaryExpression(await, true)
+                              parsePrimary(await, expression)
+                                parseSendOrFunctionLiteral(await, expression)
+                                  looksLikeFunctionBody(;)
+                                  parseSend(await, expression)
+                                    isNextIdentifier(await)
+                                    ensureIdentifier(await, expression)
+                                      listener: handleIdentifier(returnsFuture, expression)
+                                    listener: handleNoTypeArguments(()
+                                    parseArgumentsOpt(returnsFuture)
+                                      parseArguments(returnsFuture)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                    listener: handleSend(returnsFuture, ;)
+                          inAsync()
+                          reportRecoverableError(await, AwaitNotAsync)
+                            listener: handleRecoverableError(AwaitNotAsync, await, await)
+                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                    listener: endBinaryExpression(^)
+                ensureSemicolon())
+                listener: handleExpressionStatement(;)
+          notEofOrValue(}, print)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    looksLikeFunctionBody(^)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(returnsFuture, expression)
+                                                      listener: handleNoTypeArguments(()
+                                                      parseArgumentsOpt(returnsFuture)
+                                                        parseArguments(returnsFuture)
+                                                          parseArgumentsRest(()
+                                                            listener: beginArguments(()
+                                                            listener: endArguments(0, (, ))
+                                                      listener: handleSend(returnsFuture, ^)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+                                        listener: beginBinaryExpression(^)
+                                        parsePrecedenceExpression(^, 11, true)
+                                          parseUnaryExpression(^, true)
+                                            inPlainSync()
+                                            looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
+                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                            parseAwaitExpression(^, true)
+                                              listener: beginAwaitExpression(await)
+                                              parsePrecedenceExpression(await, 16, true)
+                                                parseUnaryExpression(await, true)
+                                                  parsePrimary(await, expression)
+                                                    parseSendOrFunctionLiteral(await, expression)
+                                                      looksLikeFunctionBody())
+                                                      parseSend(await, expression)
+                                                        isNextIdentifier(await)
+                                                        ensureIdentifier(await, expression)
+                                                          listener: handleIdentifier(returnsFuture, expression)
+                                                        listener: handleNoTypeArguments(()
+                                                        parseArgumentsOpt(returnsFuture)
+                                                          parseArguments(returnsFuture)
+                                                            parseArgumentsRest(()
+                                                              listener: beginArguments(()
+                                                              listener: endArguments(0, (, ))
+                                                        listener: handleSend(returnsFuture, ))
+                                              inAsync()
+                                              reportRecoverableError(await, AwaitNotAsync)
+                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                        listener: endBinaryExpression(^)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatement(;)
+                parseExpression(;)
+                  parsePrecedenceExpression(;, 1, true)
+                    parseUnaryExpression(;, true)
+                      inPlainSync()
+                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                      parseAwaitExpression(;, true)
+                        listener: beginAwaitExpression(await)
+                        parsePrecedenceExpression(await, 16, true)
+                          parseUnaryExpression(await, true)
+                            parsePrimary(await, expression)
+                              parseSendOrFunctionLiteral(await, expression)
+                                looksLikeFunctionBody(+)
+                                parseSend(await, expression)
+                                  isNextIdentifier(await)
+                                  ensureIdentifier(await, expression)
+                                    listener: handleIdentifier(returnsFuture, expression)
+                                  listener: handleNoTypeArguments(()
+                                  parseArgumentsOpt(returnsFuture)
+                                    parseArguments(returnsFuture)
+                                      parseArgumentsRest(()
+                                        listener: beginArguments(()
+                                        listener: endArguments(0, (, ))
+                                  listener: handleSend(returnsFuture, +)
+                        inAsync()
+                        reportRecoverableError(await, AwaitNotAsync)
+                          listener: handleRecoverableError(AwaitNotAsync, await, await)
+                        listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
+                    listener: beginBinaryExpression(+)
+                    parsePrecedenceExpression(+, 14, true)
+                      parseUnaryExpression(+, true)
+                        inPlainSync()
+                        looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
+                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                        parseAwaitExpression(+, true)
+                          listener: beginAwaitExpression(await)
+                          parsePrecedenceExpression(await, 16, true)
+                            parseUnaryExpression(await, true)
+                              parsePrimary(await, expression)
+                                parseSendOrFunctionLiteral(await, expression)
+                                  looksLikeFunctionBody(;)
+                                  parseSend(await, expression)
+                                    isNextIdentifier(await)
+                                    ensureIdentifier(await, expression)
+                                      listener: handleIdentifier(returnsFuture, expression)
+                                    listener: handleNoTypeArguments(()
+                                    parseArgumentsOpt(returnsFuture)
+                                      parseArguments(returnsFuture)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                    listener: handleSend(returnsFuture, ;)
+                          inAsync()
+                          reportRecoverableError(await, AwaitNotAsync)
+                            listener: handleRecoverableError(AwaitNotAsync, await, await)
+                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                    listener: endBinaryExpression(+)
+                ensureSemicolon())
+                listener: handleExpressionStatement(;)
+          notEofOrValue(}, print)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    looksLikeFunctionBody(+)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(returnsFuture, expression)
+                                                      listener: handleNoTypeArguments(()
+                                                      parseArgumentsOpt(returnsFuture)
+                                                        parseArguments(returnsFuture)
+                                                          parseArgumentsRest(()
+                                                            listener: beginArguments(()
+                                                            listener: endArguments(0, (, ))
+                                                      listener: handleSend(returnsFuture, +)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
+                                        listener: beginBinaryExpression(+)
+                                        parsePrecedenceExpression(+, 14, true)
+                                          parseUnaryExpression(+, true)
+                                            inPlainSync()
+                                            looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
+                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                            parseAwaitExpression(+, true)
+                                              listener: beginAwaitExpression(await)
+                                              parsePrecedenceExpression(await, 16, true)
+                                                parseUnaryExpression(await, true)
+                                                  parsePrimary(await, expression)
+                                                    parseSendOrFunctionLiteral(await, expression)
+                                                      looksLikeFunctionBody())
+                                                      parseSend(await, expression)
+                                                        isNextIdentifier(await)
+                                                        ensureIdentifier(await, expression)
+                                                          listener: handleIdentifier(returnsFuture, expression)
+                                                        listener: handleNoTypeArguments(()
+                                                        parseArgumentsOpt(returnsFuture)
+                                                          parseArguments(returnsFuture)
+                                                            parseArgumentsRest(()
+                                                              listener: beginArguments(()
+                                                              listener: endArguments(0, (, ))
+                                                        listener: handleSend(returnsFuture, ))
+                                              inAsync()
+                                              reportRecoverableError(await, AwaitNotAsync)
+                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                        listener: endBinaryExpression(+)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatement(;)
+                parseExpression(;)
+                  parsePrecedenceExpression(;, 1, true)
+                    parseUnaryExpression(;, true)
+                      inPlainSync()
+                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                      parseAwaitExpression(;, true)
+                        listener: beginAwaitExpression(await)
+                        parsePrecedenceExpression(await, 16, true)
+                          parseUnaryExpression(await, true)
+                            parsePrimary(await, expression)
+                              parseSendOrFunctionLiteral(await, expression)
+                                looksLikeFunctionBody(-)
+                                parseSend(await, expression)
+                                  isNextIdentifier(await)
+                                  ensureIdentifier(await, expression)
+                                    listener: handleIdentifier(returnsFuture, expression)
+                                  listener: handleNoTypeArguments(()
+                                  parseArgumentsOpt(returnsFuture)
+                                    parseArguments(returnsFuture)
+                                      parseArgumentsRest(()
+                                        listener: beginArguments(()
+                                        listener: endArguments(0, (, ))
+                                  listener: handleSend(returnsFuture, -)
+                        inAsync()
+                        reportRecoverableError(await, AwaitNotAsync)
+                          listener: handleRecoverableError(AwaitNotAsync, await, await)
+                        listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
+                    listener: beginBinaryExpression(-)
+                    parsePrecedenceExpression(-, 14, true)
+                      parseUnaryExpression(-, true)
+                        inPlainSync()
+                        looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
+                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                        parseAwaitExpression(-, true)
+                          listener: beginAwaitExpression(await)
+                          parsePrecedenceExpression(await, 16, true)
+                            parseUnaryExpression(await, true)
+                              parsePrimary(await, expression)
+                                parseSendOrFunctionLiteral(await, expression)
+                                  looksLikeFunctionBody(;)
+                                  parseSend(await, expression)
+                                    isNextIdentifier(await)
+                                    ensureIdentifier(await, expression)
+                                      listener: handleIdentifier(returnsFuture, expression)
+                                    listener: handleNoTypeArguments(()
+                                    parseArgumentsOpt(returnsFuture)
+                                      parseArguments(returnsFuture)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                    listener: handleSend(returnsFuture, ;)
+                          inAsync()
+                          reportRecoverableError(await, AwaitNotAsync)
+                            listener: handleRecoverableError(AwaitNotAsync, await, await)
+                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                    listener: endBinaryExpression(-)
+                ensureSemicolon())
+                listener: handleExpressionStatement(;)
+          notEofOrValue(}, print)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    looksLikeFunctionBody(-)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(returnsFuture, expression)
+                                                      listener: handleNoTypeArguments(()
+                                                      parseArgumentsOpt(returnsFuture)
+                                                        parseArguments(returnsFuture)
+                                                          parseArgumentsRest(()
+                                                            listener: beginArguments(()
+                                                            listener: endArguments(0, (, ))
+                                                      listener: handleSend(returnsFuture, -)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
+                                        listener: beginBinaryExpression(-)
+                                        parsePrecedenceExpression(-, 14, true)
+                                          parseUnaryExpression(-, true)
+                                            inPlainSync()
+                                            looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
+                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                            parseAwaitExpression(-, true)
+                                              listener: beginAwaitExpression(await)
+                                              parsePrecedenceExpression(await, 16, true)
+                                                parseUnaryExpression(await, true)
+                                                  parsePrimary(await, expression)
+                                                    parseSendOrFunctionLiteral(await, expression)
+                                                      looksLikeFunctionBody())
+                                                      parseSend(await, expression)
+                                                        isNextIdentifier(await)
+                                                        ensureIdentifier(await, expression)
+                                                          listener: handleIdentifier(returnsFuture, expression)
+                                                        listener: handleNoTypeArguments(()
+                                                        parseArgumentsOpt(returnsFuture)
+                                                          parseArguments(returnsFuture)
+                                                            parseArgumentsRest(()
+                                                              listener: beginArguments(()
+                                                              listener: endArguments(0, (, ))
+                                                        listener: handleSend(returnsFuture, ))
+                                              inAsync()
+                                              reportRecoverableError(await, AwaitNotAsync)
+                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                        listener: endBinaryExpression(-)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, !)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(!)
+                  parseExpressionStatement(;)
+                    parseExpression(;)
+                      parsePrecedenceExpression(;, 1, true)
+                        parseUnaryExpression(;, true)
+                          parsePrecedenceExpression(!, 16, true)
+                            parseUnaryExpression(!, true)
+                              inPlainSync()
+                              looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                              parseAwaitExpression(!, true)
+                                listener: beginAwaitExpression(await)
+                                parsePrecedenceExpression(await, 16, true)
+                                  parseUnaryExpression(await, true)
+                                    parsePrimary(await, expression)
+                                      parseSendOrFunctionLiteral(await, expression)
+                                        looksLikeFunctionBody(^)
+                                        parseSend(await, expression)
+                                          isNextIdentifier(await)
+                                          ensureIdentifier(await, expression)
+                                            listener: handleIdentifier(returnsFuture, expression)
+                                          listener: handleNoTypeArguments(()
+                                          parseArgumentsOpt(returnsFuture)
+                                            parseArguments(returnsFuture)
+                                              parseArgumentsRest(()
+                                                listener: beginArguments(()
+                                                listener: endArguments(0, (, ))
+                                          listener: handleSend(returnsFuture, ^)
+                                inAsync()
+                                reportRecoverableError(await, AwaitNotAsync)
+                                  listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+                          listener: handleUnaryPrefixExpression(!)
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrecedenceExpression(!, 16, true)
+                              parseUnaryExpression(!, true)
+                                inPlainSync()
+                                looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                  looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                parseAwaitExpression(!, true)
+                                  listener: beginAwaitExpression(await)
+                                  parsePrecedenceExpression(await, 16, true)
+                                    parseUnaryExpression(await, true)
+                                      parsePrimary(await, expression)
+                                        parseSendOrFunctionLiteral(await, expression)
+                                          looksLikeFunctionBody(;)
+                                          parseSend(await, expression)
+                                            isNextIdentifier(await)
+                                            ensureIdentifier(await, expression)
+                                              listener: handleIdentifier(returnsFuture, expression)
+                                            listener: handleNoTypeArguments(()
+                                            parseArgumentsOpt(returnsFuture)
+                                              parseArguments(returnsFuture)
+                                                parseArgumentsRest(()
+                                                  listener: beginArguments(()
+                                                  listener: endArguments(0, (, ))
+                                            listener: handleSend(returnsFuture, ;)
+                                  inAsync()
+                                  reportRecoverableError(await, AwaitNotAsync)
+                                    listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                  listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                            listener: handleUnaryPrefixExpression(!)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon())
+                    listener: handleExpressionStatement(;)
+          notEofOrValue(}, print)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          parsePrecedenceExpression(!, 16, true)
+                                            parseUnaryExpression(!, true)
+                                              inPlainSync()
+                                              looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                              parseAwaitExpression(!, true)
+                                                listener: beginAwaitExpression(await)
+                                                parsePrecedenceExpression(await, 16, true)
+                                                  parseUnaryExpression(await, true)
+                                                    parsePrimary(await, expression)
+                                                      parseSendOrFunctionLiteral(await, expression)
+                                                        looksLikeFunctionBody(^)
+                                                        parseSend(await, expression)
+                                                          isNextIdentifier(await)
+                                                          ensureIdentifier(await, expression)
+                                                            listener: handleIdentifier(returnsFuture, expression)
+                                                          listener: handleNoTypeArguments(()
+                                                          parseArgumentsOpt(returnsFuture)
+                                                            parseArguments(returnsFuture)
+                                                              parseArgumentsRest(()
+                                                                listener: beginArguments(()
+                                                                listener: endArguments(0, (, ))
+                                                          listener: handleSend(returnsFuture, ^)
+                                                inAsync()
+                                                reportRecoverableError(await, AwaitNotAsync)
+                                                  listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                                listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+                                          listener: handleUnaryPrefixExpression(!)
+                                        listener: beginBinaryExpression(^)
+                                        parsePrecedenceExpression(^, 11, true)
+                                          parseUnaryExpression(^, true)
+                                            parsePrecedenceExpression(!, 16, true)
+                                              parseUnaryExpression(!, true)
+                                                inPlainSync()
+                                                looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                                  looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                                parseAwaitExpression(!, true)
+                                                  listener: beginAwaitExpression(await)
+                                                  parsePrecedenceExpression(await, 16, true)
+                                                    parseUnaryExpression(await, true)
+                                                      parsePrimary(await, expression)
+                                                        parseSendOrFunctionLiteral(await, expression)
+                                                          looksLikeFunctionBody())
+                                                          parseSend(await, expression)
+                                                            isNextIdentifier(await)
+                                                            ensureIdentifier(await, expression)
+                                                              listener: handleIdentifier(returnsFuture, expression)
+                                                            listener: handleNoTypeArguments(()
+                                                            parseArgumentsOpt(returnsFuture)
+                                                              parseArguments(returnsFuture)
+                                                                parseArgumentsRest(()
+                                                                  listener: beginArguments(()
+                                                                  listener: endArguments(0, (, ))
+                                                            listener: handleSend(returnsFuture, ))
+                                                  inAsync()
+                                                  reportRecoverableError(await, AwaitNotAsync)
+                                                    listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                                  listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                            listener: handleUnaryPrefixExpression(!)
+                                        listener: endBinaryExpression(^)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, var)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(var, ;, null, var, null, false)
+                looksLikeLocalFunction(f)
+                listener: beginMetadataStar(var)
+                listener: endMetadataStar(0)
+                listener: handleNoType(var)
+                listener: beginVariablesDeclaration(f, null, var)
+                parseVariablesDeclarationRest(var, true)
+                  parseOptionallyInitializedIdentifier(var)
+                    ensureIdentifier(var, localVariableDeclaration)
+                      listener: handleIdentifier(f, localVariableDeclaration)
+                    listener: beginInitializedIdentifier(f)
+                    parseVariableInitializerOpt(f)
+                      listener: beginVariableInitializer(=)
+                      parseExpression(=)
+                        parsePrecedenceExpression(=, 1, true)
+                          parseUnaryExpression(=, true)
+                            parsePrimary(=, expression)
+                              parseSendOrFunctionLiteral(=, expression)
+                                looksLikeFunctionBody(;)
+                                parseSend(=, expression)
+                                  isNextIdentifier(=)
+                                  ensureIdentifier(=, expression)
+                                    listener: handleIdentifier(returnsFuture, expression)
+                                  listener: handleNoTypeArguments(()
+                                  parseArgumentsOpt(returnsFuture)
+                                    parseArguments(returnsFuture)
+                                      parseArgumentsRest(()
+                                        listener: beginArguments(()
+                                        listener: endArguments(0, (, ))
+                                  listener: handleSend(returnsFuture, ;)
+                      listener: endVariableInitializer(=)
+                    listener: endInitializedIdentifier(f)
+                  ensureSemicolon())
+                  listener: endVariablesDeclaration(1, ;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(f)
+                  listener: beginMetadataStar(await)
+                  listener: endMetadataStar(0)
+                  listener: handleIdentifier(await, typeReference)
+                  listener: handleNoTypeArguments(f)
+                  listener: handleType(await, null)
+                  listener: beginVariablesDeclaration(f, null, null)
+                  parseVariablesDeclarationRest(await, true)
+                    parseOptionallyInitializedIdentifier(await)
+                      ensureIdentifier(await, localVariableDeclaration)
+                        listener: handleIdentifier(f, localVariableDeclaration)
+                      listener: beginInitializedIdentifier(f)
+                      parseVariableInitializerOpt(f)
+                        listener: handleNoVariableInitializer(f)
+                      listener: endInitializedIdentifier(f)
+                    ensureSemicolon(f)
+                    listener: endVariablesDeclaration(1, ;)
+          notEofOrValue(}, if)
+          parseStatement(;)
+            parseStatementX(;)
+              parseIfStatement(;)
+                listener: beginIfStatement(if)
+                ensureParenthesizedCondition(if)
+                  parseExpressionInParenthesisRest(()
+                    parseExpression(()
+                      parsePrecedenceExpression((, 1, true)
+                        parseUnaryExpression((, true)
+                          inPlainSync()
+                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                          parseAwaitExpression((, true)
+                            listener: beginAwaitExpression(await)
+                            parsePrecedenceExpression(await, 16, true)
+                              parseUnaryExpression(await, true)
+                                parsePrimary(await, expression)
+                                  parseSendOrFunctionLiteral(await, expression)
+                                    parseSend(await, expression)
+                                      isNextIdentifier(await)
+                                      ensureIdentifier(await, expression)
+                                        listener: handleIdentifier(f, expression)
+                                      listener: handleNoTypeArguments())
+                                      parseArgumentsOpt(f)
+                                        listener: handleNoArguments())
+                                      listener: handleSend(f, ))
+                            inAsync()
+                            reportRecoverableError(await, AwaitNotAsync)
+                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                    ensureCloseParen(f, ()
+                  listener: handleParenthesizedCondition(()
+                listener: beginThenStatement({)
+                parseStatement())
+                  parseStatementX())
+                    parseBlock(), BlockKind(statement))
+                      ensureBlock(), null, null)
+                      listener: beginBlock({, BlockKind(statement))
+                      notEofOrValue(}, })
+                      listener: endBlock(0, {, }, BlockKind(statement))
+                listener: endThenStatement(})
+                listener: beginElseStatement(else)
+                parseStatement(else)
+                  parseStatementX(else)
+                    parseIfStatement(else)
+                      listener: beginIfStatement(if)
+                      ensureParenthesizedCondition(if)
+                        parseExpressionInParenthesisRest(()
+                          parseExpression(()
+                            parsePrecedenceExpression((, 1, true)
+                              parseUnaryExpression((, true)
+                                parsePrecedenceExpression(!, 16, true)
+                                  parseUnaryExpression(!, true)
+                                    inPlainSync()
+                                    looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                      looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                    parseAwaitExpression(!, true)
+                                      listener: beginAwaitExpression(await)
+                                      parsePrecedenceExpression(await, 16, true)
+                                        parseUnaryExpression(await, true)
+                                          parsePrimary(await, expression)
+                                            parseSendOrFunctionLiteral(await, expression)
+                                              parseSend(await, expression)
+                                                isNextIdentifier(await)
+                                                ensureIdentifier(await, expression)
+                                                  listener: handleIdentifier(f, expression)
+                                                listener: handleNoTypeArguments())
+                                                parseArgumentsOpt(f)
+                                                  listener: handleNoArguments())
+                                                listener: handleSend(f, ))
+                                      inAsync()
+                                      reportRecoverableError(await, AwaitNotAsync)
+                                        listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                      listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                listener: handleUnaryPrefixExpression(!)
+                          ensureCloseParen(f, ()
+                        listener: handleParenthesizedCondition(()
+                      listener: beginThenStatement({)
+                      parseStatement())
+                        parseStatementX())
+                          parseBlock(), BlockKind(statement))
+                            ensureBlock(), null, null)
+                            listener: beginBlock({, BlockKind(statement))
+                            notEofOrValue(}, })
+                            listener: endBlock(0, {, }, BlockKind(statement))
+                      listener: endThenStatement(})
+                      listener: endIfStatement(if, null)
+                listener: endElseStatement(else)
+                listener: endIfStatement(if, else)
+          notEofOrValue(}, print)
+          parseStatement(})
+            parseStatementX(})
+              parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(})
+                  parseExpression(})
+                    parsePrecedenceExpression(}, 1, true)
+                      parseUnaryExpression(}, true)
+                        parsePrimary(}, expression)
+                          parseSendOrFunctionLiteral(}, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(}, expression)
+                              isNextIdentifier(})
+                              ensureIdentifier(}, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(f, expression)
+                                                      listener: handleNoTypeArguments())
+                                                      parseArgumentsOpt(f)
+                                                        listener: handleNoArguments())
+                                                      listener: handleSend(f, ))
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, xor)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(xor)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(xor, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(xor)
+                                parseArguments(xor)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(f, expression)
+                                                      listener: handleNoTypeArguments(,)
+                                                      parseArgumentsOpt(f)
+                                                        listener: handleNoArguments(,)
+                                                      listener: handleSend(f, ,)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
+                                    parseExpression(,)
+                                      parsePrecedenceExpression(,, 1, true)
+                                        parseUnaryExpression(,, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression(,, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(f, expression)
+                                                      listener: handleNoTypeArguments(,)
+                                                      parseArgumentsOpt(f)
+                                                        listener: handleNoArguments(,)
+                                                      listener: handleSend(f, ,)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
+                                    parseExpression(,)
+                                      parsePrecedenceExpression(,, 1, true)
+                                        parseUnaryExpression(,, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression(,, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(f, expression)
+                                                      listener: handleNoTypeArguments())
+                                                      parseArgumentsOpt(f)
+                                                        listener: handleNoArguments())
+                                                      listener: handleSend(f, ))
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                    listener: endArguments(3, (, ))
+                              listener: handleSend(xor, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatement(;)
+                parseExpression(;)
+                  parsePrecedenceExpression(;, 1, true)
+                    parseUnaryExpression(;, true)
+                      inPlainSync()
+                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                      parseAwaitExpression(;, true)
+                        listener: beginAwaitExpression(await)
+                        parsePrecedenceExpression(await, 16, true)
+                          parseUnaryExpression(await, true)
+                            parsePrimary(await, expression)
+                              parseSendOrFunctionLiteral(await, expression)
+                                parseSend(await, expression)
+                                  isNextIdentifier(await)
+                                  ensureIdentifier(await, expression)
+                                    listener: handleIdentifier(f, expression)
+                                  listener: handleNoTypeArguments(^)
+                                  parseArgumentsOpt(f)
+                                    listener: handleNoArguments(^)
+                                  listener: handleSend(f, ^)
+                        inAsync()
+                        reportRecoverableError(await, AwaitNotAsync)
+                          listener: handleRecoverableError(AwaitNotAsync, await, await)
+                        listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+                    listener: beginBinaryExpression(^)
+                    parsePrecedenceExpression(^, 11, true)
+                      parseUnaryExpression(^, true)
+                        inPlainSync()
+                        looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
+                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                        parseAwaitExpression(^, true)
+                          listener: beginAwaitExpression(await)
+                          parsePrecedenceExpression(await, 16, true)
+                            parseUnaryExpression(await, true)
+                              parsePrimary(await, expression)
+                                parseSendOrFunctionLiteral(await, expression)
+                                  parseSend(await, expression)
+                                    isNextIdentifier(await)
+                                    ensureIdentifier(await, expression)
+                                      listener: handleIdentifier(f, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(f)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(f, ;)
+                          inAsync()
+                          reportRecoverableError(await, AwaitNotAsync)
+                            listener: handleRecoverableError(AwaitNotAsync, await, await)
+                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                    listener: endBinaryExpression(^)
+                ensureSemicolon(f)
+                listener: handleExpressionStatement(;)
+          notEofOrValue(}, print)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(f, expression)
+                                                      listener: handleNoTypeArguments(^)
+                                                      parseArgumentsOpt(f)
+                                                        listener: handleNoArguments(^)
+                                                      listener: handleSend(f, ^)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+                                        listener: beginBinaryExpression(^)
+                                        parsePrecedenceExpression(^, 11, true)
+                                          parseUnaryExpression(^, true)
+                                            inPlainSync()
+                                            looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
+                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                            parseAwaitExpression(^, true)
+                                              listener: beginAwaitExpression(await)
+                                              parsePrecedenceExpression(await, 16, true)
+                                                parseUnaryExpression(await, true)
+                                                  parsePrimary(await, expression)
+                                                    parseSendOrFunctionLiteral(await, expression)
+                                                      parseSend(await, expression)
+                                                        isNextIdentifier(await)
+                                                        ensureIdentifier(await, expression)
+                                                          listener: handleIdentifier(f, expression)
+                                                        listener: handleNoTypeArguments())
+                                                        parseArgumentsOpt(f)
+                                                          listener: handleNoArguments())
+                                                        listener: handleSend(f, ))
+                                              inAsync()
+                                              reportRecoverableError(await, AwaitNotAsync)
+                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                        listener: endBinaryExpression(^)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatement(;)
+                parseExpression(;)
+                  parsePrecedenceExpression(;, 1, true)
+                    parseUnaryExpression(;, true)
+                      inPlainSync()
+                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                      parseAwaitExpression(;, true)
+                        listener: beginAwaitExpression(await)
+                        parsePrecedenceExpression(await, 16, true)
+                          parseUnaryExpression(await, true)
+                            parsePrimary(await, expression)
+                              parseSendOrFunctionLiteral(await, expression)
+                                parseSend(await, expression)
+                                  isNextIdentifier(await)
+                                  ensureIdentifier(await, expression)
+                                    listener: handleIdentifier(f, expression)
+                                  listener: handleNoTypeArguments(+)
+                                  parseArgumentsOpt(f)
+                                    listener: handleNoArguments(+)
+                                  listener: handleSend(f, +)
+                        inAsync()
+                        reportRecoverableError(await, AwaitNotAsync)
+                          listener: handleRecoverableError(AwaitNotAsync, await, await)
+                        listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
+                    listener: beginBinaryExpression(+)
+                    parsePrecedenceExpression(+, 14, true)
+                      parseUnaryExpression(+, true)
+                        inPlainSync()
+                        looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
+                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                        parseAwaitExpression(+, true)
+                          listener: beginAwaitExpression(await)
+                          parsePrecedenceExpression(await, 16, true)
+                            parseUnaryExpression(await, true)
+                              parsePrimary(await, expression)
+                                parseSendOrFunctionLiteral(await, expression)
+                                  parseSend(await, expression)
+                                    isNextIdentifier(await)
+                                    ensureIdentifier(await, expression)
+                                      listener: handleIdentifier(f, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(f)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(f, ;)
+                          inAsync()
+                          reportRecoverableError(await, AwaitNotAsync)
+                            listener: handleRecoverableError(AwaitNotAsync, await, await)
+                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                    listener: endBinaryExpression(+)
+                ensureSemicolon(f)
+                listener: handleExpressionStatement(;)
+          notEofOrValue(}, print)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(f, expression)
+                                                      listener: handleNoTypeArguments(+)
+                                                      parseArgumentsOpt(f)
+                                                        listener: handleNoArguments(+)
+                                                      listener: handleSend(f, +)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
+                                        listener: beginBinaryExpression(+)
+                                        parsePrecedenceExpression(+, 14, true)
+                                          parseUnaryExpression(+, true)
+                                            inPlainSync()
+                                            looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
+                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                            parseAwaitExpression(+, true)
+                                              listener: beginAwaitExpression(await)
+                                              parsePrecedenceExpression(await, 16, true)
+                                                parseUnaryExpression(await, true)
+                                                  parsePrimary(await, expression)
+                                                    parseSendOrFunctionLiteral(await, expression)
+                                                      parseSend(await, expression)
+                                                        isNextIdentifier(await)
+                                                        ensureIdentifier(await, expression)
+                                                          listener: handleIdentifier(f, expression)
+                                                        listener: handleNoTypeArguments())
+                                                        parseArgumentsOpt(f)
+                                                          listener: handleNoArguments())
+                                                        listener: handleSend(f, ))
+                                              inAsync()
+                                              reportRecoverableError(await, AwaitNotAsync)
+                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                        listener: endBinaryExpression(+)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatement(;)
+                parseExpression(;)
+                  parsePrecedenceExpression(;, 1, true)
+                    parseUnaryExpression(;, true)
+                      inPlainSync()
+                      looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                      parseAwaitExpression(;, true)
+                        listener: beginAwaitExpression(await)
+                        parsePrecedenceExpression(await, 16, true)
+                          parseUnaryExpression(await, true)
+                            parsePrimary(await, expression)
+                              parseSendOrFunctionLiteral(await, expression)
+                                parseSend(await, expression)
+                                  isNextIdentifier(await)
+                                  ensureIdentifier(await, expression)
+                                    listener: handleIdentifier(f, expression)
+                                  listener: handleNoTypeArguments(-)
+                                  parseArgumentsOpt(f)
+                                    listener: handleNoArguments(-)
+                                  listener: handleSend(f, -)
+                        inAsync()
+                        reportRecoverableError(await, AwaitNotAsync)
+                          listener: handleRecoverableError(AwaitNotAsync, await, await)
+                        listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
+                    listener: beginBinaryExpression(-)
+                    parsePrecedenceExpression(-, 14, true)
+                      parseUnaryExpression(-, true)
+                        inPlainSync()
+                        looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
+                          looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                        parseAwaitExpression(-, true)
+                          listener: beginAwaitExpression(await)
+                          parsePrecedenceExpression(await, 16, true)
+                            parseUnaryExpression(await, true)
+                              parsePrimary(await, expression)
+                                parseSendOrFunctionLiteral(await, expression)
+                                  parseSend(await, expression)
+                                    isNextIdentifier(await)
+                                    ensureIdentifier(await, expression)
+                                      listener: handleIdentifier(f, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(f)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(f, ;)
+                          inAsync()
+                          reportRecoverableError(await, AwaitNotAsync)
+                            listener: handleRecoverableError(AwaitNotAsync, await, await)
+                          listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                    listener: endBinaryExpression(-)
+                ensureSemicolon(f)
+                listener: handleExpressionStatement(;)
+          notEofOrValue(}, print)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          inPlainSync()
+                                          looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
+                                            looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                          parseAwaitExpression((, true)
+                                            listener: beginAwaitExpression(await)
+                                            parsePrecedenceExpression(await, 16, true)
+                                              parseUnaryExpression(await, true)
+                                                parsePrimary(await, expression)
+                                                  parseSendOrFunctionLiteral(await, expression)
+                                                    parseSend(await, expression)
+                                                      isNextIdentifier(await)
+                                                      ensureIdentifier(await, expression)
+                                                        listener: handleIdentifier(f, expression)
+                                                      listener: handleNoTypeArguments(-)
+                                                      parseArgumentsOpt(f)
+                                                        listener: handleNoArguments(-)
+                                                      listener: handleSend(f, -)
+                                            inAsync()
+                                            reportRecoverableError(await, AwaitNotAsync)
+                                              listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                            listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
+                                        listener: beginBinaryExpression(-)
+                                        parsePrecedenceExpression(-, 14, true)
+                                          parseUnaryExpression(-, true)
+                                            inPlainSync()
+                                            looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
+                                              looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                            parseAwaitExpression(-, true)
+                                              listener: beginAwaitExpression(await)
+                                              parsePrecedenceExpression(await, 16, true)
+                                                parseUnaryExpression(await, true)
+                                                  parsePrimary(await, expression)
+                                                    parseSendOrFunctionLiteral(await, expression)
+                                                      parseSend(await, expression)
+                                                        isNextIdentifier(await)
+                                                        ensureIdentifier(await, expression)
+                                                          listener: handleIdentifier(f, expression)
+                                                        listener: handleNoTypeArguments())
+                                                        parseArgumentsOpt(f)
+                                                          listener: handleNoArguments())
+                                                        listener: handleSend(f, ))
+                                              inAsync()
+                                              reportRecoverableError(await, AwaitNotAsync)
+                                                listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                              listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                        listener: endBinaryExpression(-)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, !)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(!)
+                  parseExpressionStatement(;)
+                    parseExpression(;)
+                      parsePrecedenceExpression(;, 1, true)
+                        parseUnaryExpression(;, true)
+                          parsePrecedenceExpression(!, 16, true)
+                            parseUnaryExpression(!, true)
+                              inPlainSync()
+                              looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                              parseAwaitExpression(!, true)
+                                listener: beginAwaitExpression(await)
+                                parsePrecedenceExpression(await, 16, true)
+                                  parseUnaryExpression(await, true)
+                                    parsePrimary(await, expression)
+                                      parseSendOrFunctionLiteral(await, expression)
+                                        parseSend(await, expression)
+                                          isNextIdentifier(await)
+                                          ensureIdentifier(await, expression)
+                                            listener: handleIdentifier(f, expression)
+                                          listener: handleNoTypeArguments(^)
+                                          parseArgumentsOpt(f)
+                                            listener: handleNoArguments(^)
+                                          listener: handleSend(f, ^)
+                                inAsync()
+                                reportRecoverableError(await, AwaitNotAsync)
+                                  listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+                          listener: handleUnaryPrefixExpression(!)
+                        listener: beginBinaryExpression(^)
+                        parsePrecedenceExpression(^, 11, true)
+                          parseUnaryExpression(^, true)
+                            parsePrecedenceExpression(!, 16, true)
+                              parseUnaryExpression(!, true)
+                                inPlainSync()
+                                looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                  looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                parseAwaitExpression(!, true)
+                                  listener: beginAwaitExpression(await)
+                                  parsePrecedenceExpression(await, 16, true)
+                                    parseUnaryExpression(await, true)
+                                      parsePrimary(await, expression)
+                                        parseSendOrFunctionLiteral(await, expression)
+                                          parseSend(await, expression)
+                                            isNextIdentifier(await)
+                                            ensureIdentifier(await, expression)
+                                              listener: handleIdentifier(f, expression)
+                                            listener: handleNoTypeArguments(;)
+                                            parseArgumentsOpt(f)
+                                              listener: handleNoArguments(;)
+                                            listener: handleSend(f, ;)
+                                  inAsync()
+                                  reportRecoverableError(await, AwaitNotAsync)
+                                    listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                  listener: endInvalidAwaitExpression(await, ;, AwaitNotAsync)
+                            listener: handleUnaryPrefixExpression(!)
+                        listener: endBinaryExpression(^)
+                    ensureSemicolon(f)
+                    listener: handleExpressionStatement(;)
+          notEofOrValue(}, print)
+          parseStatement(;)
+            parseStatementX(;)
+              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                looksLikeLocalFunction(print)
+                parseExpressionStatement(;)
+                  parseExpression(;)
+                    parsePrecedenceExpression(;, 1, true)
+                      parseUnaryExpression(;, true)
+                        parsePrimary(;, expression)
+                          parseSendOrFunctionLiteral(;, expression)
+                            looksLikeFunctionBody(;)
+                            parseSend(;, expression)
+                              isNextIdentifier(;)
+                              ensureIdentifier(;, expression)
+                                listener: handleIdentifier(print, expression)
+                              listener: handleNoTypeArguments(()
+                              parseArgumentsOpt(print)
+                                parseArguments(print)
+                                  parseArgumentsRest(()
+                                    listener: beginArguments(()
+                                    parseExpression(()
+                                      parsePrecedenceExpression((, 1, true)
+                                        parseUnaryExpression((, true)
+                                          parsePrecedenceExpression(!, 16, true)
+                                            parseUnaryExpression(!, true)
+                                              inPlainSync()
+                                              looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                              parseAwaitExpression(!, true)
+                                                listener: beginAwaitExpression(await)
+                                                parsePrecedenceExpression(await, 16, true)
+                                                  parseUnaryExpression(await, true)
+                                                    parsePrimary(await, expression)
+                                                      parseSendOrFunctionLiteral(await, expression)
+                                                        parseSend(await, expression)
+                                                          isNextIdentifier(await)
+                                                          ensureIdentifier(await, expression)
+                                                            listener: handleIdentifier(f, expression)
+                                                          listener: handleNoTypeArguments(^)
+                                                          parseArgumentsOpt(f)
+                                                            listener: handleNoArguments(^)
+                                                          listener: handleSend(f, ^)
+                                                inAsync()
+                                                reportRecoverableError(await, AwaitNotAsync)
+                                                  listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                                listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
+                                          listener: handleUnaryPrefixExpression(!)
+                                        listener: beginBinaryExpression(^)
+                                        parsePrecedenceExpression(^, 11, true)
+                                          parseUnaryExpression(^, true)
+                                            parsePrecedenceExpression(!, 16, true)
+                                              parseUnaryExpression(!, true)
+                                                inPlainSync()
+                                                looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
+                                                  looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                                                parseAwaitExpression(!, true)
+                                                  listener: beginAwaitExpression(await)
+                                                  parsePrecedenceExpression(await, 16, true)
+                                                    parseUnaryExpression(await, true)
+                                                      parsePrimary(await, expression)
+                                                        parseSendOrFunctionLiteral(await, expression)
+                                                          parseSend(await, expression)
+                                                            isNextIdentifier(await)
+                                                            ensureIdentifier(await, expression)
+                                                              listener: handleIdentifier(f, expression)
+                                                            listener: handleNoTypeArguments())
+                                                            parseArgumentsOpt(f)
+                                                              listener: handleNoArguments())
+                                                            listener: handleSend(f, ))
+                                                  inAsync()
+                                                  reportRecoverableError(await, AwaitNotAsync)
+                                                    listener: handleRecoverableError(AwaitNotAsync, await, await)
+                                                  listener: endInvalidAwaitExpression(await, ), AwaitNotAsync)
+                                            listener: handleUnaryPrefixExpression(!)
+                                        listener: endBinaryExpression(^)
+                                    listener: endArguments(1, (, ))
+                              listener: handleSend(print, ;)
+                  ensureSemicolon())
+                  listener: handleExpressionStatement(;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(x)
+                  listener: beginMetadataStar(await)
+                  listener: endMetadataStar(0)
+                  listener: handleIdentifier(await, typeReference)
+                  listener: handleNoTypeArguments(x)
+                  listener: handleType(await, null)
+                  listener: beginVariablesDeclaration(x, null, null)
+                  parseVariablesDeclarationRest(await, true)
+                    parseOptionallyInitializedIdentifier(await)
+                      ensureIdentifier(await, localVariableDeclaration)
+                        listener: handleIdentifier(x, localVariableDeclaration)
+                      listener: beginInitializedIdentifier(x)
+                      parseVariableInitializerOpt(x)
+                        listener: handleNoVariableInitializer(x)
+                      listener: endInitializedIdentifier(x)
+                    ensureSemicolon(x)
+                    listener: endVariablesDeclaration(1, ;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(y)
+                  listener: beginMetadataStar(await)
+                  listener: endMetadataStar(0)
+                  listener: handleIdentifier(await, typeReference)
+                  listener: handleNoTypeArguments(y)
+                  listener: handleType(await, null)
+                  listener: beginVariablesDeclaration(y, null, null)
+                  parseVariablesDeclarationRest(await, true)
+                    parseOptionallyInitializedIdentifier(await)
+                      ensureIdentifier(await, localVariableDeclaration)
+                        listener: handleIdentifier(y, localVariableDeclaration)
+                      listener: beginInitializedIdentifier(y)
+                      parseVariableInitializerOpt(y)
+                        listener: handleNoVariableInitializer(y)
+                      listener: endInitializedIdentifier(y)
+                    parseOptionallyInitializedIdentifier(,)
+                      ensureIdentifier(,, localVariableDeclaration)
+                        listener: handleIdentifier(z, localVariableDeclaration)
+                      listener: beginInitializedIdentifier(z)
+                      parseVariableInitializerOpt(z)
+                        listener: handleNoVariableInitializer(z)
+                      listener: endInitializedIdentifier(z)
+                    ensureSemicolon(z)
+                    listener: endVariablesDeclaration(2, ;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(x2)
+                  listener: beginMetadataStar(await)
+                  listener: endMetadataStar(0)
+                  listener: handleIdentifier(await, typeReference)
+                  listener: handleNoTypeArguments(x2)
+                  listener: handleType(await, null)
+                  listener: beginVariablesDeclaration(x2, null, null)
+                  parseVariablesDeclarationRest(await, true)
+                    parseOptionallyInitializedIdentifier(await)
+                      ensureIdentifier(await, localVariableDeclaration)
+                        listener: handleIdentifier(x2, localVariableDeclaration)
+                      listener: beginInitializedIdentifier(x2)
+                      parseVariableInitializerOpt(x2)
+                        listener: beginVariableInitializer(=)
+                        parseExpression(=)
+                          parsePrecedenceExpression(=, 1, true)
+                            parseUnaryExpression(=, true)
+                              inPlainSync()
+                              looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
+                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                              parsePrimary(=, expression)
+                                inPlainSync()
+                                parseSendOrFunctionLiteral(=, expression)
+                                  parseSend(=, expression)
+                                    isNextIdentifier(=)
+                                    ensureIdentifier(=, expression)
+                                      inPlainSync()
+                                      listener: handleIdentifier(await, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(await)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(await, ;)
+                        listener: endVariableInitializer(=)
+                      listener: endInitializedIdentifier(x2)
+                    ensureSemicolon(await)
+                    listener: endVariablesDeclaration(1, ;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(y2)
+                  listener: beginMetadataStar(await)
+                  listener: endMetadataStar(0)
+                  listener: handleIdentifier(await, typeReference)
+                  listener: handleNoTypeArguments(y2)
+                  listener: handleType(await, null)
+                  listener: beginVariablesDeclaration(y2, null, null)
+                  parseVariablesDeclarationRest(await, true)
+                    parseOptionallyInitializedIdentifier(await)
+                      ensureIdentifier(await, localVariableDeclaration)
+                        listener: handleIdentifier(y2, localVariableDeclaration)
+                      listener: beginInitializedIdentifier(y2)
+                      parseVariableInitializerOpt(y2)
+                        listener: beginVariableInitializer(=)
+                        parseExpression(=)
+                          parsePrecedenceExpression(=, 1, true)
+                            parseUnaryExpression(=, true)
+                              inPlainSync()
+                              looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
+                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                              parsePrimary(=, expression)
+                                inPlainSync()
+                                parseSendOrFunctionLiteral(=, expression)
+                                  parseSend(=, expression)
+                                    isNextIdentifier(=)
+                                    ensureIdentifier(=, expression)
+                                      inPlainSync()
+                                      listener: handleIdentifier(await, expression)
+                                    listener: handleNoTypeArguments(,)
+                                    parseArgumentsOpt(await)
+                                      listener: handleNoArguments(,)
+                                    listener: handleSend(await, ,)
+                        listener: endVariableInitializer(=)
+                      listener: endInitializedIdentifier(y2)
+                    parseOptionallyInitializedIdentifier(,)
+                      ensureIdentifier(,, localVariableDeclaration)
+                        listener: handleIdentifier(z2, localVariableDeclaration)
+                      listener: beginInitializedIdentifier(z2)
+                      parseVariableInitializerOpt(z2)
+                        listener: beginVariableInitializer(=)
+                        parseExpression(=)
+                          parsePrecedenceExpression(=, 1, true)
+                            parseUnaryExpression(=, true)
+                              inPlainSync()
+                              looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
+                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
+                              parsePrimary(=, expression)
+                                inPlainSync()
+                                parseSendOrFunctionLiteral(=, expression)
+                                  parseSend(=, expression)
+                                    isNextIdentifier(=)
+                                    ensureIdentifier(=, expression)
+                                      inPlainSync()
+                                      listener: handleIdentifier(await, expression)
+                                    listener: handleNoTypeArguments(;)
+                                    parseArgumentsOpt(await)
+                                      listener: handleNoArguments(;)
+                                    listener: handleSend(await, ;)
+                        listener: endVariableInitializer(=)
+                      listener: endInitializedIdentifier(z2)
+                    ensureSemicolon(await)
+                    listener: endVariablesDeclaration(2, ;)
+          notEofOrValue(}, await)
+          parseStatement(;)
+            parseStatementX(;)
+              inPlainSync()
+              looksLikeAwaitExpression(;, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatementOrDeclaration(;, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
+                  looksLikeLocalFunction(foo)
+                  listener: beginMetadataStar(await)
+                  listener: endMetadataStar(0)
+                  listener: handleNoTypeVariables(()
+                  listener: beginLocalFunctionDeclaration(await)
+                  listener: handleIdentifier(await, typeReference)
+                  listener: handleNoTypeArguments(foo)
+                  listener: handleType(await, null)
+                  parseNamedFunctionRest(await, await, foo, false)
+                    listener: beginFunctionName(foo)
+                    ensureIdentifier(await, localFunctionDeclaration)
+                      listener: handleIdentifier(foo, localFunctionDeclaration)
+                    listener: endFunctionName(await, ()
+                    parseFormalParametersRequiredOpt(foo, MemberKind.Local)
+                      parseFormalParametersRest((, MemberKind.Local)
+                        listener: beginFormalParameters((, MemberKind.Local)
+                        parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.Local)
+                          parseMetadataStar(()
+                            listener: beginMetadataStar(int)
+                            listener: endMetadataStar(0)
+                          listener: beginFormalParameter(int, MemberKind.Local, null, null, null)
+                          listener: handleIdentifier(int, typeReference)
+                          listener: handleNoTypeArguments(bar)
+                          listener: handleType(int, null)
+                          ensureIdentifier(int, formalParameterDeclaration)
+                            listener: handleIdentifier(bar, formalParameterDeclaration)
+                          listener: handleFormalParameterWithoutValue())
+                          listener: endFormalParameter(null, null, null, bar, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+                        listener: endFormalParameters(1, (, ), MemberKind.Local)
+                    parseInitializersOpt())
+                      listener: handleNoInitializers()
+                    parseAsyncOptBody(), false, false)
+                      parseAsyncModifierOpt())
+                        listener: handleAsyncModifier(null, null)
+                        inPlainSync()
+                      parseFunctionBody(), false, false)
+                        listener: beginBlockFunctionBody({)
+                        notEofOrValue(}, return)
+                        parseStatement({)
+                          parseStatementX({)
+                            parseReturnStatement({)
+                              listener: beginReturnStatement(return)
+                              parseExpression(return)
+                                parsePrecedenceExpression(return, 1, true)
+                                  parseUnaryExpression(return, true)
+                                    parsePrimary(return, expression)
+                                      parseNewExpression(return)
+                                        isNextIdentifier(new)
+                                        listener: beginNewExpression(new)
+                                        parseConstructorReference(new, ConstructorReferenceContext.New, null)
+                                          ensureIdentifier(new, constructorReference)
+                                            inPlainSync()
+                                            listener: handleIdentifier(await, constructorReference)
+                                          listener: beginConstructorReference(await)
+                                          parseQualifiedRestOpt(await, constructorReferenceContinuation)
+                                          listener: handleNoTypeArguments(()
+                                          listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                          listener: endConstructorReference(await, null, (, ConstructorReferenceContext.New)
+                                        parseConstructorInvocationArguments(await)
+                                          parseArgumentsRest(()
+                                            listener: beginArguments(()
+                                            listener: endArguments(0, (, ))
+                                        listener: endNewExpression(new)
+                              ensureSemicolon())
+                              listener: endReturnStatement(true, return, ;)
+                              inGenerator()
+                        notEofOrValue(}, })
+                        listener: endBlockFunctionBody(1, {, })
+                    listener: endLocalFunctionDeclaration(})
+          notEofOrValue(}, await)
+          parseStatement(})
+            parseStatementX(})
+              inPlainSync()
+              looksLikeAwaitExpression(}, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
+              parseExpressionStatementOrDeclaration(}, false)
+                parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false)
+                  looksLikeLocalFunction(bar)
+                  listener: beginMetadataStar(await)
+                  listener: endMetadataStar(0)
+                  listener: handleNoTypeVariables(()
+                  listener: beginLocalFunctionDeclaration(await)
+                  listener: handleIdentifier(await, typeReference)
+                  listener: handleNoTypeArguments(bar)
+                  listener: handleType(await, null)
+                  parseNamedFunctionRest(await, await, bar, false)
+                    listener: beginFunctionName(bar)
+                    ensureIdentifier(await, localFunctionDeclaration)
+                      listener: handleIdentifier(bar, localFunctionDeclaration)
+                    listener: endFunctionName(await, ()
+                    parseFormalParametersRequiredOpt(bar, MemberKind.Local)
+                      parseFormalParametersRest((, MemberKind.Local)
+                        listener: beginFormalParameters((, MemberKind.Local)
+                        parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.Local)
+                          parseMetadataStar(()
+                            listener: beginMetadataStar(await)
+                            listener: endMetadataStar(0)
+                          listener: beginFormalParameter(await, MemberKind.Local, null, null, null)
+                          listener: handleIdentifier(await, typeReference)
+                          listener: handleNoTypeArguments(baz)
+                          listener: handleType(await, null)
+                          ensureIdentifier(await, formalParameterDeclaration)
+                            listener: handleIdentifier(baz, formalParameterDeclaration)
+                          listener: handleFormalParameterWithoutValue(,)
+                          listener: endFormalParameter(null, null, null, baz, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+                        parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.Local)
+                          parseMetadataStar(,)
+                            listener: beginMetadataStar(await)
+                            listener: endMetadataStar(0)
+                          listener: beginFormalParameter(await, MemberKind.Local, null, null, null)
+                          listener: handleIdentifier(await, typeReference)
+                          listener: handleNoTypeArguments(baz2)
+                          listener: handleType(await, null)
+                          ensureIdentifier(await, formalParameterDeclaration)
+                            listener: handleIdentifier(baz2, formalParameterDeclaration)
+                          listener: handleFormalParameterWithoutValue(,)
+                          listener: endFormalParameter(null, null, null, baz2, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+                        parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.Local)
+                          parseMetadataStar(,)
+                            listener: beginMetadataStar(await)
+                            listener: endMetadataStar(0)
+                          listener: beginFormalParameter(await, MemberKind.Local, null, null, null)
+                          listener: handleIdentifier(await, typeReference)
+                          listener: handleNoTypeArguments(baz3)
+                          listener: handleType(await, null)
+                          ensureIdentifier(await, formalParameterDeclaration)
+                            listener: handleIdentifier(baz3, formalParameterDeclaration)
+                          listener: handleFormalParameterWithoutValue())
+                          listener: endFormalParameter(null, null, null, baz3, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
+                        listener: endFormalParameters(3, (, ), MemberKind.Local)
+                    parseInitializersOpt())
+                      listener: handleNoInitializers()
+                    parseAsyncOptBody(), false, false)
+                      parseAsyncModifierOpt())
+                        listener: handleAsyncModifier(null, null)
+                        inPlainSync()
+                      parseFunctionBody(), false, false)
+                        listener: beginBlockFunctionBody({)
+                        notEofOrValue(}, return)
+                        parseStatement({)
+                          parseStatementX({)
+                            parseReturnStatement({)
+                              listener: beginReturnStatement(return)
+                              parseExpression(return)
+                                parsePrecedenceExpression(return, 1, true)
+                                  parseUnaryExpression(return, true)
+                                    parsePrimary(return, expression)
+                                      parseSendOrFunctionLiteral(return, expression)
+                                        parseSend(return, expression)
+                                          isNextIdentifier(return)
+                                          ensureIdentifier(return, expression)
+                                            listener: handleIdentifier(baz, expression)
+                                          listener: handleNoTypeArguments(;)
+                                          parseArgumentsOpt(baz)
+                                            listener: handleNoArguments(;)
+                                          listener: handleSend(baz, ;)
+                              ensureSemicolon(baz)
+                              listener: endReturnStatement(true, return, ;)
+                              inGenerator()
+                        notEofOrValue(}, })
+                        listener: endBlockFunctionBody(1, {, })
+                    listener: endLocalFunctionDeclaration(})
+          notEofOrValue(}, })
+          listener: endBlockFunctionBody(31, {, })
+        listener: endTopLevelMethod(void, null, })
+  listener: endTopLevelDeclaration(bool)
+  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
+    parseMetadataStar(})
+      listener: beginMetadataStar(bool)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(})
+      listener: beginTopLevelMember(bool)
+      parseTopLevelMethod(}, null, null, }, Instance of 'SimpleType', null, xor, false)
+        listener: beginTopLevelMethod(}, null, null)
+        listener: handleIdentifier(bool, typeReference)
+        listener: handleNoTypeArguments(xor)
+        listener: handleType(bool, null)
+        ensureIdentifierPotentiallyRecovered(bool, topLevelFunctionDeclaration, false)
+          listener: handleIdentifier(xor, topLevelFunctionDeclaration)
+        parseMethodTypeVar(xor)
+          listener: handleNoTypeVariables(()
+        parseGetterOrFormalParameters(xor, xor, false, MemberKind.TopLevelMethod)
+          parseFormalParameters(xor, MemberKind.TopLevelMethod)
+            parseFormalParametersRest((, MemberKind.TopLevelMethod)
+              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
+              parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+                parseMetadataStar(()
+                  listener: beginMetadataStar(bool)
+                  listener: endMetadataStar(0)
+                listener: beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
+                listener: handleIdentifier(bool, typeReference)
+                listener: handleNoTypeArguments(a)
+                listener: handleType(bool, null)
+                ensureIdentifier(bool, formalParameterDeclaration)
+                  listener: handleIdentifier(a, formalParameterDeclaration)
+                listener: handleFormalParameterWithoutValue(,)
+                listener: endFormalParameter(null, null, null, a, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+              parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+                parseMetadataStar(,)
+                  listener: beginMetadataStar(bool)
+                  listener: endMetadataStar(0)
+                listener: beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
+                listener: handleIdentifier(bool, typeReference)
+                listener: handleNoTypeArguments(b)
+                listener: handleType(bool, null)
+                ensureIdentifier(bool, formalParameterDeclaration)
+                  listener: handleIdentifier(b, formalParameterDeclaration)
+                listener: handleFormalParameterWithoutValue(,)
+                listener: endFormalParameter(null, null, null, b, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+              parseFormalParameter(,, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+                parseMetadataStar(,)
+                  listener: beginMetadataStar(bool)
+                  listener: endMetadataStar(0)
+                listener: beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
+                listener: handleIdentifier(bool, typeReference)
+                listener: handleNoTypeArguments(c)
+                listener: handleType(bool, null)
+                ensureIdentifier(bool, formalParameterDeclaration)
+                  listener: handleIdentifier(c, formalParameterDeclaration)
+                listener: handleFormalParameterWithoutValue())
+                listener: endFormalParameter(null, null, null, c, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
+              listener: endFormalParameters(3, (, ), MemberKind.TopLevelMethod)
+        parseAsyncModifierOpt())
+          listener: handleAsyncModifier(null, null)
+          inPlainSync()
+        parseFunctionBody(), false, false)
+          listener: beginBlockFunctionBody({)
+          notEofOrValue(}, return)
+          parseStatement({)
+            parseStatementX({)
+              parseReturnStatement({)
+                listener: beginReturnStatement(return)
+                parseExpression(return)
+                  parsePrecedenceExpression(return, 1, true)
+                    parseUnaryExpression(return, true)
+                      parsePrimary(return, expression)
+                        parseSendOrFunctionLiteral(return, expression)
+                          parseSend(return, expression)
+                            isNextIdentifier(return)
+                            ensureIdentifier(return, expression)
+                              listener: handleIdentifier(b, expression)
+                            listener: handleNoTypeArguments(^)
+                            parseArgumentsOpt(b)
+                              listener: handleNoArguments(^)
+                            listener: handleSend(b, ^)
+                    listener: beginBinaryExpression(^)
+                    parsePrecedenceExpression(^, 11, true)
+                      parseUnaryExpression(^, true)
+                        parsePrimary(^, expression)
+                          parseSendOrFunctionLiteral(^, expression)
+                            parseSend(^, expression)
+                              isNextIdentifier(^)
+                              ensureIdentifier(^, expression)
+                                listener: handleIdentifier(b, expression)
+                              listener: handleNoTypeArguments(^)
+                              parseArgumentsOpt(b)
+                                listener: handleNoArguments(^)
+                              listener: handleSend(b, ^)
+                    listener: endBinaryExpression(^)
+                    listener: beginBinaryExpression(^)
+                    parsePrecedenceExpression(^, 11, true)
+                      parseUnaryExpression(^, true)
+                        parsePrimary(^, expression)
+                          parseSendOrFunctionLiteral(^, expression)
+                            parseSend(^, expression)
+                              isNextIdentifier(^)
+                              ensureIdentifier(^, expression)
+                                listener: handleIdentifier(c, expression)
+                              listener: handleNoTypeArguments(;)
+                              parseArgumentsOpt(c)
+                                listener: handleNoArguments(;)
+                              listener: handleSend(c, ;)
+                    listener: endBinaryExpression(^)
+                ensureSemicolon(c)
+                listener: endReturnStatement(true, return, ;)
+                inGenerator()
+          notEofOrValue(}, })
+          listener: endBlockFunctionBody(1, {, })
+        listener: endTopLevelMethod(bool, null, })
+  listener: endTopLevelDeclaration(class)
+  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
+    parseMetadataStar(})
+      listener: beginMetadataStar(class)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext')
+      parseClassOrNamedMixinApplication(null, null, null, class)
+        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(await, classOrMixinDeclaration)
+        listener: handleNoTypeVariables({)
+        listener: beginClassDeclaration(class, null, null, null, await)
+        parseClass(await, class, class, await)
+          parseClassHeaderOpt(await, class, class)
+            parseClassExtendsOpt(await)
+              listener: handleNoType(await)
+              listener: handleClassExtends(null, 1)
+            parseClassWithClauseOpt(await)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinOrEnumImplementsOpt(await)
+              listener: handleImplements(null, 0)
+            listener: handleClassHeader(class, class, null)
+          parseClassOrMixinOrExtensionBody(await, DeclarationKind.Class, await)
+            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
+            notEofOrValue(}, })
+            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
+          listener: endClassDeclaration(class, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(Future)
+  listener: endCompilationUnit(4, )
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.parser.expect b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.parser.expect
new file mode 100644
index 0000000..e111af6d
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.parser.expect
@@ -0,0 +1,105 @@
+Future<bool> returnsFuture() => new Future.value(true);
+
+
+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;
+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);
+
+
+await x;
+await y, z;
+await x2 = await;
+await y2 = await, z2 = await;
+await foo(int bar) {
+return new await();
+}
+await bar(await baz, await baz2, await baz3) {
+return baz;
+}
+}
+
+bool xor(bool a, bool b, bool c) {
+return b ^ b ^ c;
+}
+
+class await {}
+
+
+Future[StringToken]<[BeginToken]bool[StringToken]>[SimpleToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] =>[SimpleToken] new[KeywordToken] Future[StringToken].[SimpleToken]value[StringToken]([BeginToken]true[KeywordToken])[SimpleToken];[SimpleToken]
+
+
+void[KeywordToken] foo[StringToken]([BeginToken])[SimpleToken] {[BeginToken]
+await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+if[KeywordToken] ([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+else[KeywordToken] if[KeywordToken] ([BeginToken]![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+xor[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken],[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken],[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] ^[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] ^[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] +[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] +[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] -[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] -[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] ^[SimpleToken] ![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+print[StringToken]([BeginToken]![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] ^[SimpleToken] ![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+
+var[KeywordToken] f[StringToken] =[SimpleToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] f[StringToken];[SimpleToken]
+if[KeywordToken] ([BeginToken]await[KeywordToken] f[StringToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+else[KeywordToken] if[KeywordToken] ([BeginToken]![SimpleToken]await[KeywordToken] f[StringToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+xor[StringToken]([BeginToken]await[KeywordToken] f[StringToken],[SimpleToken] await[KeywordToken] f[StringToken],[SimpleToken] await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] f[StringToken] ^[SimpleToken] await[KeywordToken] f[StringToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] f[StringToken] ^[SimpleToken] await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] f[StringToken] +[SimpleToken] await[KeywordToken] f[StringToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] f[StringToken] +[SimpleToken] await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] f[StringToken] -[SimpleToken] await[KeywordToken] f[StringToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] f[StringToken] -[SimpleToken] await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+![SimpleToken]await[KeywordToken] f[StringToken] ^[SimpleToken] ![SimpleToken]await[KeywordToken] f[StringToken];[SimpleToken]
+print[StringToken]([BeginToken]![SimpleToken]await[KeywordToken] f[StringToken] ^[SimpleToken] ![SimpleToken]await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+
+
+await[KeywordToken] x[StringToken];[SimpleToken]
+await[KeywordToken] y[StringToken],[SimpleToken] z[StringToken];[SimpleToken]
+await[KeywordToken] x2[StringToken] =[SimpleToken] await[KeywordToken];[SimpleToken]
+await[KeywordToken] y2[StringToken] =[SimpleToken] await[KeywordToken],[SimpleToken] z2[StringToken] =[SimpleToken] await[KeywordToken];[SimpleToken]
+await[KeywordToken] foo[StringToken]([BeginToken]int[StringToken] bar[StringToken])[SimpleToken] {[BeginToken]
+return[KeywordToken] new[KeywordToken] await[KeywordToken]([BeginToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+await[KeywordToken] bar[StringToken]([BeginToken]await[KeywordToken] baz[StringToken],[SimpleToken] await[KeywordToken] baz2[StringToken],[SimpleToken] await[KeywordToken] baz3[StringToken])[SimpleToken] {[BeginToken]
+return[KeywordToken] baz[StringToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+
+bool[StringToken] xor[StringToken]([BeginToken]bool[StringToken] a[StringToken],[SimpleToken] bool[StringToken] b[StringToken],[SimpleToken] bool[StringToken] c[StringToken])[SimpleToken] {[BeginToken]
+return[KeywordToken] b[StringToken] ^[SimpleToken] b[StringToken] ^[SimpleToken] c[StringToken];[SimpleToken]
+}[SimpleToken]
+
+class[KeywordToken] await[KeywordToken] {[BeginToken]}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.scanner.expect b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.scanner.expect
new file mode 100644
index 0000000..e111af6d
--- /dev/null
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.scanner.expect
@@ -0,0 +1,105 @@
+Future<bool> returnsFuture() => new Future.value(true);
+
+
+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;
+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);
+
+
+await x;
+await y, z;
+await x2 = await;
+await y2 = await, z2 = await;
+await foo(int bar) {
+return new await();
+}
+await bar(await baz, await baz2, await baz3) {
+return baz;
+}
+}
+
+bool xor(bool a, bool b, bool c) {
+return b ^ b ^ c;
+}
+
+class await {}
+
+
+Future[StringToken]<[BeginToken]bool[StringToken]>[SimpleToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] =>[SimpleToken] new[KeywordToken] Future[StringToken].[SimpleToken]value[StringToken]([BeginToken]true[KeywordToken])[SimpleToken];[SimpleToken]
+
+
+void[KeywordToken] foo[StringToken]([BeginToken])[SimpleToken] {[BeginToken]
+await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+if[KeywordToken] ([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+else[KeywordToken] if[KeywordToken] ([BeginToken]![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+xor[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken],[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken],[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] ^[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] ^[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] +[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] +[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] -[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] -[SimpleToken] await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] ^[SimpleToken] ![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+print[StringToken]([BeginToken]![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken] ^[SimpleToken] ![SimpleToken]await[KeywordToken] returnsFuture[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+
+var[KeywordToken] f[StringToken] =[SimpleToken] returnsFuture[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] f[StringToken];[SimpleToken]
+if[KeywordToken] ([BeginToken]await[KeywordToken] f[StringToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+else[KeywordToken] if[KeywordToken] ([BeginToken]![SimpleToken]await[KeywordToken] f[StringToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+xor[StringToken]([BeginToken]await[KeywordToken] f[StringToken],[SimpleToken] await[KeywordToken] f[StringToken],[SimpleToken] await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] f[StringToken] ^[SimpleToken] await[KeywordToken] f[StringToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] f[StringToken] ^[SimpleToken] await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] f[StringToken] +[SimpleToken] await[KeywordToken] f[StringToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] f[StringToken] +[SimpleToken] await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+await[KeywordToken] f[StringToken] -[SimpleToken] await[KeywordToken] f[StringToken];[SimpleToken]
+print[StringToken]([BeginToken]await[KeywordToken] f[StringToken] -[SimpleToken] await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+![SimpleToken]await[KeywordToken] f[StringToken] ^[SimpleToken] ![SimpleToken]await[KeywordToken] f[StringToken];[SimpleToken]
+print[StringToken]([BeginToken]![SimpleToken]await[KeywordToken] f[StringToken] ^[SimpleToken] ![SimpleToken]await[KeywordToken] f[StringToken])[SimpleToken];[SimpleToken]
+
+
+await[KeywordToken] x[StringToken];[SimpleToken]
+await[KeywordToken] y[StringToken],[SimpleToken] z[StringToken];[SimpleToken]
+await[KeywordToken] x2[StringToken] =[SimpleToken] await[KeywordToken];[SimpleToken]
+await[KeywordToken] y2[StringToken] =[SimpleToken] await[KeywordToken],[SimpleToken] z2[StringToken] =[SimpleToken] await[KeywordToken];[SimpleToken]
+await[KeywordToken] foo[StringToken]([BeginToken]int[StringToken] bar[StringToken])[SimpleToken] {[BeginToken]
+return[KeywordToken] new[KeywordToken] await[KeywordToken]([BeginToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+await[KeywordToken] bar[StringToken]([BeginToken]await[KeywordToken] baz[StringToken],[SimpleToken] await[KeywordToken] baz2[StringToken],[SimpleToken] await[KeywordToken] baz3[StringToken])[SimpleToken] {[BeginToken]
+return[KeywordToken] baz[StringToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+
+bool[StringToken] xor[StringToken]([BeginToken]bool[StringToken] a[StringToken],[SimpleToken] bool[StringToken] b[StringToken],[SimpleToken] bool[StringToken] c[StringToken])[SimpleToken] {[BeginToken]
+return[KeywordToken] b[StringToken] ^[SimpleToken] b[StringToken] ^[SimpleToken] c[StringToken];[SimpleToken]
+}[SimpleToken]
+
+class[KeywordToken] await[KeywordToken] {[BeginToken]}[SimpleToken]
+[SimpleToken]
diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
index 36f1d49..06dc2d8 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
@@ -691,8 +691,8 @@
                           parsePrecedenceExpression(return, 1, true)
                             parseUnaryExpression(return, true)
                               inPlainSync()
-                              looksLikeAwaitExpression(return)
-                                looksLikeExpression(await)
+                              looksLikeAwaitExpression(return, AwaitOrYieldContext.UnaryExpression)
+                                looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
index 1db298e..8b1d7ab 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
@@ -648,8 +648,8 @@
                   parsePrecedenceExpression(return, 1, true)
                     parseUnaryExpression(return, true)
                       inPlainSync()
-                      looksLikeAwaitExpression(return)
-                        looksLikeExpression(await)
+                      looksLikeAwaitExpression(return, AwaitOrYieldContext.UnaryExpression)
+                        looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
diff --git a/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
index 73a9892..61cc64b 100644
--- a/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
@@ -102,8 +102,8 @@
           notEofOrValue(}, yield)
           parseStatement({)
             parseStatementX({)
-              looksLikeYieldStatement({)
-                looksLikeExpression(yield)
+              looksLikeYieldStatement({, AwaitOrYieldContext.Statement)
+                looksLikeExpressionAfterAwaitOrYield(yield, AwaitOrYieldContext.Statement)
               parseYieldStatement({)
                 listener: beginYieldStatement(yield)
                 parseExpression(yield)
diff --git a/pkg/front_end/test/parser_test_parser.dart b/pkg/front_end/test/parser_test_parser.dart
index d29de47..91a7954 100644
--- a/pkg/front_end/test/parser_test_parser.dart
+++ b/pkg/front_end/test/parser_test_parser.dart
@@ -12,6 +12,8 @@
 import 'package:_fe_analyzer_shared/src/parser/listener.dart' show Listener;
 import 'package:_fe_analyzer_shared/src/parser/member_kind.dart';
 import 'package:_fe_analyzer_shared/src/parser/parser.dart' show Parser;
+import 'package:_fe_analyzer_shared/src/parser/parser_impl.dart'
+    show AwaitOrYieldContext;
 import 'package:_fe_analyzer_shared/src/parser/token_stream_rewriter.dart';
 import 'package:_fe_analyzer_shared/src/parser/type_info.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
@@ -2090,28 +2092,29 @@
   }
 
   @override
-  bool looksLikeExpression(Token token) {
-    doPrint('looksLikeExpression(' '$token)');
+  bool looksLikeExpressionAfterAwaitOrYield(
+      Token token, AwaitOrYieldContext context) {
+    doPrint('looksLikeExpressionAfterAwaitOrYield(' '$token, ' '$context)');
     indent++;
-    var result = super.looksLikeExpression(token);
+    var result = super.looksLikeExpressionAfterAwaitOrYield(token, context);
     indent--;
     return result;
   }
 
   @override
-  bool looksLikeAwaitExpression(Token token) {
-    doPrint('looksLikeAwaitExpression(' '$token)');
+  bool looksLikeAwaitExpression(Token token, AwaitOrYieldContext context) {
+    doPrint('looksLikeAwaitExpression(' '$token, ' '$context)');
     indent++;
-    var result = super.looksLikeAwaitExpression(token);
+    var result = super.looksLikeAwaitExpression(token, context);
     indent--;
     return result;
   }
 
   @override
-  bool looksLikeYieldStatement(Token token) {
-    doPrint('looksLikeYieldStatement(' '$token)');
+  bool looksLikeYieldStatement(Token token, AwaitOrYieldContext context) {
+    doPrint('looksLikeYieldStatement(' '$token, ' '$context)');
     indent++;
-    var result = super.looksLikeYieldStatement(token);
+    var result = super.looksLikeYieldStatement(token, context);
     indent--;
     return result;
   }
diff --git a/pkg/front_end/test/parser_test_parser_creator.dart b/pkg/front_end/test/parser_test_parser_creator.dart
index 17c7ff3..af64ccf 100644
--- a/pkg/front_end/test/parser_test_parser_creator.dart
+++ b/pkg/front_end/test/parser_test_parser_creator.dart
@@ -50,6 +50,7 @@
 import 'package:_fe_analyzer_shared/src/parser/listener.dart' show Listener;
 import 'package:_fe_analyzer_shared/src/parser/member_kind.dart';
 import 'package:_fe_analyzer_shared/src/parser/parser.dart' show Parser;
+import 'package:_fe_analyzer_shared/src/parser/parser_impl.dart' show AwaitOrYieldContext;
 import 'package:_fe_analyzer_shared/src/parser/token_stream_rewriter.dart';
 import 'package:_fe_analyzer_shared/src/parser/type_info.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
diff --git a/runtime/tests/vm/vm.status b/runtime/tests/vm/vm.status
index f0f2c06..32f10592 100644
--- a/runtime/tests/vm/vm.status
+++ b/runtime/tests/vm/vm.status
@@ -14,6 +14,7 @@
 dart/analyze_snapshot_binary_test: Pass, Slow # Runs various subprocesses for testing AOT.
 dart/boxmint_test: Pass, Slow # Uses slow path
 dart/byte_array_optimized_test: Pass, Slow
+dart/byte_array_test: Pass, Slow # Uses --opt-counter-threshold=10
 dart/data_uri_import_test/none: SkipByDesign
 dart/disassemble_aot_test: Pass, Slow # Spawns several subprocesses
 dart/emit_aot_size_info_flag_test: Pass, Slow # Spawns several subprocesses
@@ -31,6 +32,7 @@
 dart_2/analyze_snapshot_binary_test: Pass, Slow # Runs various subprocesses for testing AOT.
 dart_2/boxmint_test: Pass, Slow # Uses slow path
 dart_2/byte_array_optimized_test: Pass, Slow
+dart_2/byte_array_test: Pass, Slow # Uses --opt-counter-threshold=10
 dart_2/data_uri_import_test/none: SkipByDesign
 dart_2/disassemble_aot_test: Pass, Slow # Spawns several subprocesses
 dart_2/emit_aot_size_info_flag_test: Pass, Slow # Spawns several subprocesses
diff --git a/tools/VERSION b/tools/VERSION
index 4f0a8bd..cb3be23 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 18
 PATCH 0
-PRERELEASE 235
+PRERELEASE 236
 PRERELEASE_PATCH 0
\ No newline at end of file