Version 2.18.0-236.0.dev
Merge commit 'dd9a2dca24a5a50bffcb088368b003414c737aa3' into 'dev'
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
