From 4a49580e7e5b31426afe9268b6a4c7cd0ff1ddb4 Mon Sep 17 00:00:00 2001 From: Jens Johansen Date: Fri, 18 Jun 2021 10:20:32 +0000 Subject: [PATCH] [parser] Consume (and use) identifier looking like start of next top level declaration as class name Fixes https://github.com/dart-lang/sdk/issues/46346 Change-Id: Ie688d0838b612c2eda157bbf9e2fa799bae96fb1 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/203762 Commit-Queue: Jens Johansen Reviewed-by: Johnni Winther Reviewed-by: Brian Wilkerson --- .../src/parser/identifier_context_impl.dart | 19 +- .../error_recovery/issue_46346.dart | 69 + .../error_recovery/issue_46346.dart.expect | 1314 +++++++++++ .../issue_46346.dart.intertwined.expect | 2048 +++++++++++++++++ .../issue_46346.dart.parser.expect | 141 ++ .../issue_46346.dart.scanner.expect | 141 ++ .../error_recovery/issue_46346_prime_1.dart | 69 + .../issue_46346_prime_1.dart.expect | 1452 ++++++++++++ ...ssue_46346_prime_1.dart.intertwined.expect | 1979 ++++++++++++++++ .../issue_46346_prime_1.dart.parser.expect | 141 ++ .../issue_46346_prime_1.dart.scanner.expect | 141 ++ .../error_recovery/issue_46346_prime_2.dart | 1 + .../issue_46346_prime_2.dart.expect | 40 + ...ssue_46346_prime_2.dart.intertwined.expect | 60 + .../issue_46346_prime_2.dart.parser.expect | 5 + .../issue_46346_prime_2.dart.scanner.expect | 3 + .../identifier/built_in_illegal_test.dart | 137 +- .../identifier/built_in_illegal_test.dart | 111 +- 18 files changed, 7656 insertions(+), 215 deletions(-) create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346.dart create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.intertwined.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.parser.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.scanner.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.intertwined.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.parser.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.scanner.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.intertwined.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.parser.expect create mode 100644 pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.scanner.expect diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart b/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart index eb7ab976ab1..b2359965e54 100644 --- a/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart +++ b/pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart @@ -58,9 +58,22 @@ class ClassOrMixinOrExtensionIdentifierContext extends IdentifierContext { } // Recovery - if (looksLikeStartOfNextTopLevelDeclaration(identifier) || - isOneOfOrEof(identifier, - const ['<', '{', 'extends', 'with', 'implements', 'on'])) { + const List afterIdentifier = const [ + '<', + '{', + 'extends', + 'with', + 'implements', + 'on', + '=', + ]; + if (identifier.isEof || + (looksLikeStartOfNextTopLevelDeclaration(identifier) && + (identifier.next == null || + !isOneOfOrEof(identifier.next!, afterIdentifier))) || + (isOneOfOrEof(identifier, afterIdentifier) && + (identifier.next == null || + !isOneOfOrEof(identifier.next!, afterIdentifier)))) { identifier = parser.insertSyntheticIdentifier(token, this, message: codes.templateExpectedIdentifier.withArguments(identifier)); } else if (identifier.type.isBuiltIn) { diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart new file mode 100644 index 00000000000..3920233ca55 --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart @@ -0,0 +1,69 @@ +class abstract {} +class as {} +class assert {} +class async {} +class await {} +class break {} +class case {} +class catch {} +class class {} +class const {} +class continue {} +class covariant {} +class default {} +class deferred {} +class do {} +class dynamic {} +class else {} +class enum {} +class export {} +class extends {} +class extension {} +class external {} +class factory {} +class false {} +class final {} +class finally {} +class for {} +class Function {} +class get {} +class hide {} +class if {} +class implements {} +class import {} +class in {} +class inout {} +class interface {} +class is {} +class late {} +class library {} +class mixin {} +class native {} +class new {} +class null {} +class of {} +class on {} +class operator {} +class out {} +class part {} +class patch {} +class required {} +class rethrow {} +class return {} +class set {} +class show {} +class source {} +class static {} +class super {} +class switch {} +class sync {} +class this {} +class throw {} +class true {} +class try {} +class typedef {} +class var {} +class void {} +class while {} +class with {} +class yield {} diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.expect new file mode 100644 index 00000000000..c371313a6e8 --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.expect @@ -0,0 +1,1314 @@ +Problems reported: + +parser/error_recovery/issue_46346:1:7: Can't use 'abstract' as a name here. +class abstract {} + ^^^^^^^^ + +parser/error_recovery/issue_46346:2:7: Can't use 'as' as a name here. +class as {} + ^^ + +parser/error_recovery/issue_46346:3:7: 'assert' can't be used as an identifier because it's a keyword. +class assert {} + ^^^^^^ + +parser/error_recovery/issue_46346:6:7: 'break' can't be used as an identifier because it's a keyword. +class break {} + ^^^^^ + +parser/error_recovery/issue_46346:7:7: 'case' can't be used as an identifier because it's a keyword. +class case {} + ^^^^ + +parser/error_recovery/issue_46346:8:7: 'catch' can't be used as an identifier because it's a keyword. +class catch {} + ^^^^^ + +parser/error_recovery/issue_46346:9:7: 'class' can't be used as an identifier because it's a keyword. +class class {} + ^^^^^ + +parser/error_recovery/issue_46346:10:7: 'const' can't be used as an identifier because it's a keyword. +class const {} + ^^^^^ + +parser/error_recovery/issue_46346:11:7: 'continue' can't be used as an identifier because it's a keyword. +class continue {} + ^^^^^^^^ + +parser/error_recovery/issue_46346:12:7: Can't use 'covariant' as a name here. +class covariant {} + ^^^^^^^^^ + +parser/error_recovery/issue_46346:13:7: 'default' can't be used as an identifier because it's a keyword. +class default {} + ^^^^^^^ + +parser/error_recovery/issue_46346:14:7: Can't use 'deferred' as a name here. +class deferred {} + ^^^^^^^^ + +parser/error_recovery/issue_46346:15:7: 'do' can't be used as an identifier because it's a keyword. +class do {} + ^^ + +parser/error_recovery/issue_46346:16:7: Can't use 'dynamic' as a name here. +class dynamic {} + ^^^^^^^ + +parser/error_recovery/issue_46346:17:7: 'else' can't be used as an identifier because it's a keyword. +class else {} + ^^^^ + +parser/error_recovery/issue_46346:18:7: 'enum' can't be used as an identifier because it's a keyword. +class enum {} + ^^^^ + +parser/error_recovery/issue_46346:19:7: Can't use 'export' as a name here. +class export {} + ^^^^^^ + +parser/error_recovery/issue_46346:20:7: 'extends' can't be used as an identifier because it's a keyword. +class extends {} + ^^^^^^^ + +parser/error_recovery/issue_46346:21:7: Can't use 'extension' as a name here. +class extension {} + ^^^^^^^^^ + +parser/error_recovery/issue_46346:22:7: Can't use 'external' as a name here. +class external {} + ^^^^^^^^ + +parser/error_recovery/issue_46346:23:7: Can't use 'factory' as a name here. +class factory {} + ^^^^^^^ + +parser/error_recovery/issue_46346:24:7: 'false' can't be used as an identifier because it's a keyword. +class false {} + ^^^^^ + +parser/error_recovery/issue_46346:25:7: 'final' can't be used as an identifier because it's a keyword. +class final {} + ^^^^^ + +parser/error_recovery/issue_46346:26:7: 'finally' can't be used as an identifier because it's a keyword. +class finally {} + ^^^^^^^ + +parser/error_recovery/issue_46346:27:7: 'for' can't be used as an identifier because it's a keyword. +class for {} + ^^^ + +parser/error_recovery/issue_46346:29:7: Can't use 'get' as a name here. +class get {} + ^^^ + +parser/error_recovery/issue_46346:31:7: 'if' can't be used as an identifier because it's a keyword. +class if {} + ^^ + +parser/error_recovery/issue_46346:32:7: Can't use 'implements' as a name here. +class implements {} + ^^^^^^^^^^ + +parser/error_recovery/issue_46346:33:7: Can't use 'import' as a name here. +class import {} + ^^^^^^ + +parser/error_recovery/issue_46346:34:7: 'in' can't be used as an identifier because it's a keyword. +class in {} + ^^ + +parser/error_recovery/issue_46346:36:7: Can't use 'interface' as a name here. +class interface {} + ^^^^^^^^^ + +parser/error_recovery/issue_46346:37:7: 'is' can't be used as an identifier because it's a keyword. +class is {} + ^^ + +parser/error_recovery/issue_46346:38:7: Can't use 'late' as a name here. +class late {} + ^^^^ + +parser/error_recovery/issue_46346:39:7: Can't use 'library' as a name here. +class library {} + ^^^^^^^ + +parser/error_recovery/issue_46346:40:7: Can't use 'mixin' as a name here. +class mixin {} + ^^^^^ + +parser/error_recovery/issue_46346:42:7: 'new' can't be used as an identifier because it's a keyword. +class new {} + ^^^ + +parser/error_recovery/issue_46346:43:7: 'null' can't be used as an identifier because it's a keyword. +class null {} + ^^^^ + +parser/error_recovery/issue_46346:46:7: Can't use 'operator' as a name here. +class operator {} + ^^^^^^^^ + +parser/error_recovery/issue_46346:48:7: Can't use 'part' as a name here. +class part {} + ^^^^ + +parser/error_recovery/issue_46346:50:7: Can't use 'required' as a name here. +class required {} + ^^^^^^^^ + +parser/error_recovery/issue_46346:51:7: 'rethrow' can't be used as an identifier because it's a keyword. +class rethrow {} + ^^^^^^^ + +parser/error_recovery/issue_46346:52:7: 'return' can't be used as an identifier because it's a keyword. +class return {} + ^^^^^^ + +parser/error_recovery/issue_46346:53:7: Can't use 'set' as a name here. +class set {} + ^^^ + +parser/error_recovery/issue_46346:56:7: Can't use 'static' as a name here. +class static {} + ^^^^^^ + +parser/error_recovery/issue_46346:57:7: 'super' can't be used as an identifier because it's a keyword. +class super {} + ^^^^^ + +parser/error_recovery/issue_46346:58:7: 'switch' can't be used as an identifier because it's a keyword. +class switch {} + ^^^^^^ + +parser/error_recovery/issue_46346:60:7: 'this' can't be used as an identifier because it's a keyword. +class this {} + ^^^^ + +parser/error_recovery/issue_46346:61:7: 'throw' can't be used as an identifier because it's a keyword. +class throw {} + ^^^^^ + +parser/error_recovery/issue_46346:62:7: 'true' can't be used as an identifier because it's a keyword. +class true {} + ^^^^ + +parser/error_recovery/issue_46346:63:7: 'try' can't be used as an identifier because it's a keyword. +class try {} + ^^^ + +parser/error_recovery/issue_46346:64:7: Can't use 'typedef' as a name here. +class typedef {} + ^^^^^^^ + +parser/error_recovery/issue_46346:65:7: 'var' can't be used as an identifier because it's a keyword. +class var {} + ^^^ + +parser/error_recovery/issue_46346:66:7: 'void' can't be used as an identifier because it's a keyword. +class void {} + ^^^^ + +parser/error_recovery/issue_46346:67:7: 'while' can't be used as an identifier because it's a keyword. +class while {} + ^^^^^ + +parser/error_recovery/issue_46346:68:7: 'with' can't be used as an identifier because it's a keyword. +class with {} + ^^^^ + +beginCompilationUnit(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'abstract' as a name here., null, {lexeme: abstract}], abstract, abstract) + handleIdentifier(abstract, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, abstract) + handleNoType(abstract) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'as' as a name here., null, {lexeme: as}], as, as) + handleIdentifier(as, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, as) + handleNoType(as) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert) + handleIdentifier(assert, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, assert) + handleNoType(assert) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(async, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, async) + handleNoType(async) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(await, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, await) + handleNoType(await) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break) + handleIdentifier(break, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, break) + handleNoType(break) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case) + handleIdentifier(case, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, case) + handleNoType(case) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch) + handleIdentifier(catch, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, catch) + handleNoType(catch) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class) + handleIdentifier(class, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, class) + handleNoType(class) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const) + handleIdentifier(const, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, const) + handleNoType(const) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue) + handleIdentifier(continue, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, continue) + handleNoType(continue) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'covariant' as a name here., null, {lexeme: covariant}], covariant, covariant) + handleIdentifier(covariant, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, covariant) + handleNoType(covariant) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default) + handleIdentifier(default, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, default) + handleNoType(default) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'deferred' as a name here., null, {lexeme: deferred}], deferred, deferred) + handleIdentifier(deferred, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, deferred) + handleNoType(deferred) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do) + handleIdentifier(do, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, do) + handleNoType(do) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'dynamic' as a name here., null, {lexeme: dynamic}], dynamic, dynamic) + handleIdentifier(dynamic, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, dynamic) + handleNoType(dynamic) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else) + handleIdentifier(else, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, else) + handleNoType(else) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum) + handleIdentifier(enum, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, enum) + handleNoType(enum) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'export' as a name here., null, {lexeme: export}], export, export) + handleIdentifier(export, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, export) + handleNoType(export) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends) + handleIdentifier(extends, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, extends) + handleNoType(extends) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'extension' as a name here., null, {lexeme: extension}], extension, extension) + handleIdentifier(extension, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, extension) + handleNoType(extension) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'external' as a name here., null, {lexeme: external}], external, external) + handleIdentifier(external, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, external) + handleNoType(external) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'factory' as a name here., null, {lexeme: factory}], factory, factory) + handleIdentifier(factory, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, factory) + handleNoType(factory) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false) + handleIdentifier(false, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, false) + handleNoType(false) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final) + handleIdentifier(final, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, final) + handleNoType(final) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally) + handleIdentifier(finally, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, finally) + handleNoType(finally) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for) + handleIdentifier(for, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, for) + handleNoType(for) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(Function, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, Function) + handleNoType(Function) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'get' as a name here., null, {lexeme: get}], get, get) + handleIdentifier(get, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, get) + handleNoType(get) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(hide, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, hide) + handleNoType(hide) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if) + handleIdentifier(if, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, if) + handleNoType(if) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'implements' as a name here., null, {lexeme: implements}], implements, implements) + handleIdentifier(implements, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, implements) + handleNoType(implements) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'import' as a name here., null, {lexeme: import}], import, import) + handleIdentifier(import, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, import) + handleNoType(import) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in) + handleIdentifier(in, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, in) + handleNoType(in) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(inout, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, inout) + handleNoType(inout) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'interface' as a name here., null, {lexeme: interface}], interface, interface) + handleIdentifier(interface, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, interface) + handleNoType(interface) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is) + handleIdentifier(is, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, is) + handleNoType(is) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'late' as a name here., null, {lexeme: late}], late, late) + handleIdentifier(late, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, late) + handleNoType(late) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'library' as a name here., null, {lexeme: library}], library, library) + handleIdentifier(library, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, library) + handleNoType(library) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'mixin' as a name here., null, {lexeme: mixin}], mixin, mixin) + handleIdentifier(mixin, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, mixin) + handleNoType(mixin) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(native, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, native) + handleNoType(native) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new) + handleIdentifier(new, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, new) + handleNoType(new) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null) + handleIdentifier(null, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, null) + handleNoType(null) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(of, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, of) + handleNoType(of) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(on, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, on) + handleNoType(on) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'operator' as a name here., null, {lexeme: operator}], operator, operator) + handleIdentifier(operator, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, operator) + handleNoType(operator) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(out, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, out) + handleNoType(out) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'part' as a name here., null, {lexeme: part}], part, part) + handleIdentifier(part, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, part) + handleNoType(part) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(patch, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, patch) + handleNoType(patch) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'required' as a name here., null, {lexeme: required}], required, required) + handleIdentifier(required, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, required) + handleNoType(required) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow) + handleIdentifier(rethrow, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, rethrow) + handleNoType(rethrow) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return) + handleIdentifier(return, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, return) + handleNoType(return) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'set' as a name here., null, {lexeme: set}], set, set) + handleIdentifier(set, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, set) + handleNoType(set) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(show, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, show) + handleNoType(show) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(source, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, source) + handleNoType(source) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'static' as a name here., null, {lexeme: static}], static, static) + handleIdentifier(static, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, static) + handleNoType(static) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super) + handleIdentifier(super, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, super) + handleNoType(super) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch) + handleIdentifier(switch, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, switch) + handleNoType(switch) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(sync, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, sync) + handleNoType(sync) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this) + handleIdentifier(this, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, this) + handleNoType(this) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw) + handleIdentifier(throw, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, throw) + handleNoType(throw) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true) + handleIdentifier(true, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, true) + handleNoType(true) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try) + handleIdentifier(try, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, try) + handleNoType(try) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'typedef' as a name here., null, {lexeme: typedef}], typedef, typedef) + handleIdentifier(typedef, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, typedef) + handleNoType(typedef) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var) + handleIdentifier(var, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, var) + handleNoType(var) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void) + handleIdentifier(void, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, void) + handleNoType(void) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while) + handleIdentifier(while, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, while) + handleNoType(while) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with) + handleIdentifier(with, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, with) + handleNoType(with) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(yield, classOrMixinDeclaration) + handleNoTypeVariables({) + beginClassDeclaration(class, null, yield) + handleNoType(yield) + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration() +endCompilationUnit(69, ) diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.intertwined.expect new file mode 100644 index 00000000000..350e22e4b2b --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.intertwined.expect @@ -0,0 +1,2048 @@ +parseUnit(class) + skipErrorTokens(class) + listener: beginCompilationUnit(class) + syntheticPreviousToken(class) + parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext') + parseMetadataStar() + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(abstract, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'abstract' as a name here., null, {lexeme: abstract}], abstract, abstract) + listener: handleIdentifier(abstract, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, abstract) + parseClass(abstract, class, class, abstract) + parseClassHeaderOpt(abstract, class, class) + parseClassExtendsOpt(abstract) + listener: handleNoType(abstract) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(abstract) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(abstract) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(abstract, DeclarationKind.Class, abstract) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(as, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'as' as a name here., null, {lexeme: as}], as, as) + listener: handleIdentifier(as, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, as) + parseClass(as, class, class, as) + parseClassHeaderOpt(as, class, class) + parseClassExtendsOpt(as) + listener: handleNoType(as) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(as) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(as) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(as, DeclarationKind.Class, as) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(assert, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert) + listener: handleIdentifier(assert, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, assert) + parseClass(assert, class, class, assert) + parseClassHeaderOpt(assert, class, class) + parseClassExtendsOpt(assert) + listener: handleNoType(assert) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(assert) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(assert) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(assert, DeclarationKind.Class, assert) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(async, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, async) + parseClass(async, class, class, async) + parseClassHeaderOpt(async, class, class) + parseClassExtendsOpt(async) + listener: handleNoType(async) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(async) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(async) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(async, DeclarationKind.Class, async) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(await, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, await) + parseClass(await, class, class, await) + parseClassHeaderOpt(await, class, class) + parseClassExtendsOpt(await) + listener: handleNoType(await) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(await) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(await) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(await, DeclarationKind.Class, await) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break) + listener: handleIdentifier(break, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, break) + parseClass(break, class, class, break) + parseClassHeaderOpt(break, class, class) + parseClassExtendsOpt(break) + listener: handleNoType(break) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(break) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(break) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(break, DeclarationKind.Class, break) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case) + listener: handleIdentifier(case, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, case) + parseClass(case, class, class, case) + parseClassHeaderOpt(case, class, class) + parseClassExtendsOpt(case) + listener: handleNoType(case) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(case) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(case) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(case, DeclarationKind.Class, case) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch) + listener: handleIdentifier(catch, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, catch) + parseClass(catch, class, class, catch) + parseClassHeaderOpt(catch, class, class) + parseClassExtendsOpt(catch) + listener: handleNoType(catch) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(catch) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(catch) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(catch, DeclarationKind.Class, catch) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class) + listener: handleIdentifier(class, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, class) + parseClass(class, class, class, class) + parseClassHeaderOpt(class, class, class) + parseClassExtendsOpt(class) + listener: handleNoType(class) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(class) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(class) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(class, DeclarationKind.Class, class) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(const, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const) + listener: handleIdentifier(const, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, const) + parseClass(const, class, class, const) + parseClassHeaderOpt(const, class, class) + parseClassExtendsOpt(const) + listener: handleNoType(const) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(const) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(const) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(const, DeclarationKind.Class, const) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue) + listener: handleIdentifier(continue, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, continue) + parseClass(continue, class, class, continue) + parseClassHeaderOpt(continue, class, class) + parseClassExtendsOpt(continue) + listener: handleNoType(continue) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(continue) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(continue) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(continue, DeclarationKind.Class, continue) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(covariant, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'covariant' as a name here., null, {lexeme: covariant}], covariant, covariant) + listener: handleIdentifier(covariant, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, covariant) + parseClass(covariant, class, class, covariant) + parseClassHeaderOpt(covariant, class, class) + parseClassExtendsOpt(covariant) + listener: handleNoType(covariant) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(covariant) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(covariant) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(covariant, DeclarationKind.Class, covariant) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default) + listener: handleIdentifier(default, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, default) + parseClass(default, class, class, default) + parseClassHeaderOpt(default, class, class) + parseClassExtendsOpt(default) + listener: handleNoType(default) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(default) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(default) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(default, DeclarationKind.Class, default) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(deferred, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'deferred' as a name here., null, {lexeme: deferred}], deferred, deferred) + listener: handleIdentifier(deferred, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, deferred) + parseClass(deferred, class, class, deferred) + parseClassHeaderOpt(deferred, class, class) + parseClassExtendsOpt(deferred) + listener: handleNoType(deferred) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(deferred) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(deferred) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(deferred, DeclarationKind.Class, deferred) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do) + listener: handleIdentifier(do, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, do) + parseClass(do, class, class, do) + parseClassHeaderOpt(do, class, class) + parseClassExtendsOpt(do) + listener: handleNoType(do) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(do) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(do) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(do, DeclarationKind.Class, do) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(dynamic, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'dynamic' as a name here., null, {lexeme: dynamic}], dynamic, dynamic) + listener: handleIdentifier(dynamic, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, dynamic) + parseClass(dynamic, class, class, dynamic) + parseClassHeaderOpt(dynamic, class, class) + parseClassExtendsOpt(dynamic) + listener: handleNoType(dynamic) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(dynamic) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(dynamic) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(dynamic, DeclarationKind.Class, dynamic) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else) + listener: handleIdentifier(else, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, else) + parseClass(else, class, class, else) + parseClassHeaderOpt(else, class, class) + parseClassExtendsOpt(else) + listener: handleNoType(else) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(else) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(else) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(else, DeclarationKind.Class, else) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum) + listener: handleIdentifier(enum, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, enum) + parseClass(enum, class, class, enum) + parseClassHeaderOpt(enum, class, class) + parseClassExtendsOpt(enum) + listener: handleNoType(enum) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(enum) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(enum) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(enum, DeclarationKind.Class, enum) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(export, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'export' as a name here., null, {lexeme: export}], export, export) + listener: handleIdentifier(export, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, export) + parseClass(export, class, class, export) + parseClassHeaderOpt(export, class, class) + parseClassExtendsOpt(export) + listener: handleNoType(export) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(export) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(export) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(export, DeclarationKind.Class, export) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends) + listener: handleIdentifier(extends, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, extends) + parseClass(extends, class, class, extends) + parseClassHeaderOpt(extends, class, class) + parseClassExtendsOpt(extends) + listener: handleNoType(extends) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(extends) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(extends) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(extends, DeclarationKind.Class, extends) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(extension, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'extension' as a name here., null, {lexeme: extension}], extension, extension) + listener: handleIdentifier(extension, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, extension) + parseClass(extension, class, class, extension) + parseClassHeaderOpt(extension, class, class) + parseClassExtendsOpt(extension) + listener: handleNoType(extension) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(extension) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(extension) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(extension, DeclarationKind.Class, extension) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(external, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'external' as a name here., null, {lexeme: external}], external, external) + listener: handleIdentifier(external, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, external) + parseClass(external, class, class, external) + parseClassHeaderOpt(external, class, class) + parseClassExtendsOpt(external) + listener: handleNoType(external) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(external) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(external) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(external, DeclarationKind.Class, external) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(factory, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'factory' as a name here., null, {lexeme: factory}], factory, factory) + listener: handleIdentifier(factory, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, factory) + parseClass(factory, class, class, factory) + parseClassHeaderOpt(factory, class, class) + parseClassExtendsOpt(factory) + listener: handleNoType(factory) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(factory) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(factory) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(factory, DeclarationKind.Class, factory) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(false, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false) + listener: handleIdentifier(false, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, false) + parseClass(false, class, class, false) + parseClassHeaderOpt(false, class, class) + parseClassExtendsOpt(false) + listener: handleNoType(false) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(false) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(false) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(false, DeclarationKind.Class, false) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final) + listener: handleIdentifier(final, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, final) + parseClass(final, class, class, final) + parseClassHeaderOpt(final, class, class) + parseClassExtendsOpt(final) + listener: handleNoType(final) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(final) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(final) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(final, DeclarationKind.Class, final) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally) + listener: handleIdentifier(finally, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, finally) + parseClass(finally, class, class, finally) + parseClassHeaderOpt(finally, class, class) + parseClassExtendsOpt(finally) + listener: handleNoType(finally) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(finally) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(finally) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(finally, DeclarationKind.Class, finally) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for) + listener: handleIdentifier(for, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, for) + parseClass(for, class, class, for) + parseClassHeaderOpt(for, class, class) + parseClassExtendsOpt(for) + listener: handleNoType(for) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(for) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(for) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(for, DeclarationKind.Class, for) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(Function, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, Function) + parseClass(Function, class, class, Function) + parseClassHeaderOpt(Function, class, class) + parseClassExtendsOpt(Function) + listener: handleNoType(Function) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(Function) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(Function) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(Function, DeclarationKind.Class, Function) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(get, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'get' as a name here., null, {lexeme: get}], get, get) + listener: handleIdentifier(get, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, get) + parseClass(get, class, class, get) + parseClassHeaderOpt(get, class, class) + parseClassExtendsOpt(get) + listener: handleNoType(get) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(get) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(get) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(get, DeclarationKind.Class, get) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(hide, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, hide) + parseClass(hide, class, class, hide) + parseClassHeaderOpt(hide, class, class) + parseClassExtendsOpt(hide) + listener: handleNoType(hide) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(hide) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(hide) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(hide, DeclarationKind.Class, hide) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if) + listener: handleIdentifier(if, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, if) + parseClass(if, class, class, if) + parseClassHeaderOpt(if, class, class) + parseClassExtendsOpt(if) + listener: handleNoType(if) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(if) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(if) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(if, DeclarationKind.Class, if) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(implements, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'implements' as a name here., null, {lexeme: implements}], implements, implements) + listener: handleIdentifier(implements, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, implements) + parseClass(implements, class, class, implements) + parseClassHeaderOpt(implements, class, class) + parseClassExtendsOpt(implements) + listener: handleNoType(implements) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(implements) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(implements) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(implements, DeclarationKind.Class, implements) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(import, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'import' as a name here., null, {lexeme: import}], import, import) + listener: handleIdentifier(import, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, import) + parseClass(import, class, class, import) + parseClassHeaderOpt(import, class, class) + parseClassExtendsOpt(import) + listener: handleNoType(import) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(import) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(import) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(import, DeclarationKind.Class, import) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in) + listener: handleIdentifier(in, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, in) + parseClass(in, class, class, in) + parseClassHeaderOpt(in, class, class) + parseClassExtendsOpt(in) + listener: handleNoType(in) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(in) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(in) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(in, DeclarationKind.Class, in) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(inout, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, inout) + parseClass(inout, class, class, inout) + parseClassHeaderOpt(inout, class, class) + parseClassExtendsOpt(inout) + listener: handleNoType(inout) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(inout) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(inout) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(inout, DeclarationKind.Class, inout) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(interface, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'interface' as a name here., null, {lexeme: interface}], interface, interface) + listener: handleIdentifier(interface, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, interface) + parseClass(interface, class, class, interface) + parseClassHeaderOpt(interface, class, class) + parseClassExtendsOpt(interface) + listener: handleNoType(interface) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(interface) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(interface) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(interface, DeclarationKind.Class, interface) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is) + listener: handleIdentifier(is, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, is) + parseClass(is, class, class, is) + parseClassHeaderOpt(is, class, class) + parseClassExtendsOpt(is) + listener: handleNoType(is) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(is) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(is) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(is, DeclarationKind.Class, is) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(late, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'late' as a name here., null, {lexeme: late}], late, late) + listener: handleIdentifier(late, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, late) + parseClass(late, class, class, late) + parseClassHeaderOpt(late, class, class) + parseClassExtendsOpt(late) + listener: handleNoType(late) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(late) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(late) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(late, DeclarationKind.Class, late) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(library, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'library' as a name here., null, {lexeme: library}], library, library) + listener: handleIdentifier(library, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, library) + parseClass(library, class, class, library) + parseClassHeaderOpt(library, class, class) + parseClassExtendsOpt(library) + listener: handleNoType(library) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(library) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(library) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(library, DeclarationKind.Class, library) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(mixin, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'mixin' as a name here., null, {lexeme: mixin}], mixin, mixin) + listener: handleIdentifier(mixin, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, mixin) + parseClass(mixin, class, class, mixin) + parseClassHeaderOpt(mixin, class, class) + parseClassExtendsOpt(mixin) + listener: handleNoType(mixin) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(mixin) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(mixin) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(mixin, DeclarationKind.Class, mixin) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(native, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, native) + parseClass(native, class, class, native) + parseClassHeaderOpt(native, class, class) + parseClassExtendsOpt(native) + listener: handleNoType(native) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(native) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(native) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(native, DeclarationKind.Class, native) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(new, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new) + listener: handleIdentifier(new, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, new) + parseClass(new, class, class, new) + parseClassHeaderOpt(new, class, class) + parseClassExtendsOpt(new) + listener: handleNoType(new) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(new) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(new) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(new, DeclarationKind.Class, new) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(null, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null) + listener: handleIdentifier(null, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, null) + parseClass(null, class, class, null) + parseClassHeaderOpt(null, class, class) + parseClassExtendsOpt(null) + listener: handleNoType(null) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(null) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(null) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(null, DeclarationKind.Class, null) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(of, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, of) + parseClass(of, class, class, of) + parseClassHeaderOpt(of, class, class) + parseClassExtendsOpt(of) + listener: handleNoType(of) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(of) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(of) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(of, DeclarationKind.Class, of) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(on, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, on) + parseClass(on, class, class, on) + parseClassHeaderOpt(on, class, class) + parseClassExtendsOpt(on) + listener: handleNoType(on) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(on) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(on) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(on, DeclarationKind.Class, on) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(operator, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'operator' as a name here., null, {lexeme: operator}], operator, operator) + listener: handleIdentifier(operator, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, operator) + parseClass(operator, class, class, operator) + parseClassHeaderOpt(operator, class, class) + parseClassExtendsOpt(operator) + listener: handleNoType(operator) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(operator) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(operator) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(operator, DeclarationKind.Class, operator) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(out, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, out) + parseClass(out, class, class, out) + parseClassHeaderOpt(out, class, class) + parseClassExtendsOpt(out) + listener: handleNoType(out) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(out) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(out) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(out, DeclarationKind.Class, out) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(part, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'part' as a name here., null, {lexeme: part}], part, part) + listener: handleIdentifier(part, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, part) + parseClass(part, class, class, part) + parseClassHeaderOpt(part, class, class) + parseClassExtendsOpt(part) + listener: handleNoType(part) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(part) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(part) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(part, DeclarationKind.Class, part) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(patch, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, patch) + parseClass(patch, class, class, patch) + parseClassHeaderOpt(patch, class, class) + parseClassExtendsOpt(patch) + listener: handleNoType(patch) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(patch) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(patch) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(patch, DeclarationKind.Class, patch) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(required, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'required' as a name here., null, {lexeme: required}], required, required) + listener: handleIdentifier(required, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, required) + parseClass(required, class, class, required) + parseClassHeaderOpt(required, class, class) + parseClassExtendsOpt(required) + listener: handleNoType(required) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(required) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(required) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(required, DeclarationKind.Class, required) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow) + listener: handleIdentifier(rethrow, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, rethrow) + parseClass(rethrow, class, class, rethrow) + parseClassHeaderOpt(rethrow, class, class) + parseClassExtendsOpt(rethrow) + listener: handleNoType(rethrow) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(rethrow) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(rethrow) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(rethrow, DeclarationKind.Class, rethrow) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return) + listener: handleIdentifier(return, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, return) + parseClass(return, class, class, return) + parseClassHeaderOpt(return, class, class) + parseClassExtendsOpt(return) + listener: handleNoType(return) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(return) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(return) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(return, DeclarationKind.Class, return) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(set, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'set' as a name here., null, {lexeme: set}], set, set) + listener: handleIdentifier(set, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, set) + parseClass(set, class, class, set) + parseClassHeaderOpt(set, class, class) + parseClassExtendsOpt(set) + listener: handleNoType(set) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(set) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(set) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(set, DeclarationKind.Class, set) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(show, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, show) + parseClass(show, class, class, show) + parseClassHeaderOpt(show, class, class) + parseClassExtendsOpt(show) + listener: handleNoType(show) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(show) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(show) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(show, DeclarationKind.Class, show) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(source, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, source) + parseClass(source, class, class, source) + parseClassHeaderOpt(source, class, class) + parseClassExtendsOpt(source) + listener: handleNoType(source) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(source) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(source) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(source, DeclarationKind.Class, source) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(static, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'static' as a name here., null, {lexeme: static}], static, static) + listener: handleIdentifier(static, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, static) + parseClass(static, class, class, static) + parseClassHeaderOpt(static, class, class) + parseClassExtendsOpt(static) + listener: handleNoType(static) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(static) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(static) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(static, DeclarationKind.Class, static) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(super, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super) + listener: handleIdentifier(super, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, super) + parseClass(super, class, class, super) + parseClassHeaderOpt(super, class, class) + parseClassExtendsOpt(super) + listener: handleNoType(super) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(super) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(super) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(super, DeclarationKind.Class, super) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch) + listener: handleIdentifier(switch, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, switch) + parseClass(switch, class, class, switch) + parseClassHeaderOpt(switch, class, class) + parseClassExtendsOpt(switch) + listener: handleNoType(switch) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(switch) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(switch) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(switch, DeclarationKind.Class, switch) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(sync, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, sync) + parseClass(sync, class, class, sync) + parseClassHeaderOpt(sync, class, class) + parseClassExtendsOpt(sync) + listener: handleNoType(sync) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(sync) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(sync) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(sync, DeclarationKind.Class, sync) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(this, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this) + listener: handleIdentifier(this, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, this) + parseClass(this, class, class, this) + parseClassHeaderOpt(this, class, class) + parseClassExtendsOpt(this) + listener: handleNoType(this) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(this) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(this) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(this, DeclarationKind.Class, this) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(throw, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw) + listener: handleIdentifier(throw, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, throw) + parseClass(throw, class, class, throw) + parseClassHeaderOpt(throw, class, class) + parseClassExtendsOpt(throw) + listener: handleNoType(throw) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(throw) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(throw) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(throw, DeclarationKind.Class, throw) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(true, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true) + listener: handleIdentifier(true, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, true) + parseClass(true, class, class, true) + parseClassHeaderOpt(true, class, class) + parseClassExtendsOpt(true) + listener: handleNoType(true) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(true) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(true) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(true, DeclarationKind.Class, true) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try) + listener: handleIdentifier(try, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, try) + parseClass(try, class, class, try) + parseClassHeaderOpt(try, class, class) + parseClassExtendsOpt(try) + listener: handleNoType(try) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(try) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(try) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(try, DeclarationKind.Class, try) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(typedef, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'typedef' as a name here., null, {lexeme: typedef}], typedef, typedef) + listener: handleIdentifier(typedef, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, typedef) + parseClass(typedef, class, class, typedef) + parseClassHeaderOpt(typedef, class, class) + parseClassExtendsOpt(typedef) + listener: handleNoType(typedef) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(typedef) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(typedef) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(typedef, DeclarationKind.Class, typedef) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var) + listener: handleIdentifier(var, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, var) + parseClass(var, class, class, var) + parseClassHeaderOpt(var, class, class) + parseClassExtendsOpt(var) + listener: handleNoType(var) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(var) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(var) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(var, DeclarationKind.Class, var) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void) + listener: handleIdentifier(void, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, void) + parseClass(void, class, class, void) + parseClassHeaderOpt(void, class, class) + parseClassExtendsOpt(void) + listener: handleNoType(void) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(void) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(void) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(void, DeclarationKind.Class, void) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while) + listener: handleIdentifier(while, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, while) + parseClass(while, class, class, while) + parseClassHeaderOpt(while, class, class) + parseClassExtendsOpt(while) + listener: handleNoType(while) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(while) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(while) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(while, DeclarationKind.Class, while) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with) + listener: handleIdentifier(with, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, with) + parseClass(with, class, class, with) + parseClassHeaderOpt(with, class, class) + parseClassExtendsOpt(with) + listener: handleNoType(with) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(with) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(with) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(with, DeclarationKind.Class, with) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') + parseMetadataStar(}) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(}, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(yield, classOrMixinDeclaration) + listener: handleNoTypeVariables({) + listener: beginClassDeclaration(class, null, yield) + parseClass(yield, class, class, yield) + parseClassHeaderOpt(yield, class, class) + parseClassExtendsOpt(yield) + listener: handleNoType(yield) + listener: handleClassExtends(null, 1) + parseWithClauseOpt(yield) + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt(yield) + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassOrMixinOrExtensionBody(yield, DeclarationKind.Class, yield) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration() + reportAllErrorTokens(class) + listener: endCompilationUnit(69, ) diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.parser.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.parser.expect new file mode 100644 index 00000000000..54c447e8cb6 --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.parser.expect @@ -0,0 +1,141 @@ +class abstract {} +class as {} +class assert {} +class async {} +class await {} +class break {} +class case {} +class catch {} +class class {} +class const {} +class continue {} +class covariant {} +class default {} +class deferred {} +class do {} +class dynamic {} +class else {} +class enum {} +class export {} +class extends {} +class extension {} +class external {} +class factory {} +class false {} +class final {} +class finally {} +class for {} +class Function {} +class get {} +class hide {} +class if {} +class implements {} +class import {} +class in {} +class inout {} +class interface {} +class is {} +class late {} +class library {} +class mixin {} +class native {} +class new {} +class null {} +class of {} +class on {} +class operator {} +class out {} +class part {} +class patch {} +class required {} +class rethrow {} +class return {} +class set {} +class show {} +class source {} +class static {} +class super {} +class switch {} +class sync {} +class this {} +class throw {} +class true {} +class try {} +class typedef {} +class var {} +class void {} +class while {} +class with {} +class yield {} + + +class[KeywordToken] abstract[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] as[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] assert[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] async[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] await[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] break[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] case[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] catch[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] class[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] const[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] continue[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] covariant[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] default[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] deferred[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] do[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] dynamic[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] else[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] enum[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] export[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] extends[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] extension[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] external[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] factory[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] false[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] final[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] finally[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] for[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] Function[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] get[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] hide[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] if[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] implements[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] import[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] in[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] inout[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] interface[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] is[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] late[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] library[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] mixin[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] native[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] new[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] null[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] of[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] on[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] operator[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] out[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] part[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] patch[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] required[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] rethrow[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] return[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] set[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] show[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] source[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] static[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] super[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] switch[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] sync[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] this[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] throw[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] true[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] try[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] typedef[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] var[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] void[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] while[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] with[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] yield[KeywordToken] {[BeginToken]}[SimpleToken] +[SimpleToken] diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.scanner.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.scanner.expect new file mode 100644 index 00000000000..54c447e8cb6 --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.scanner.expect @@ -0,0 +1,141 @@ +class abstract {} +class as {} +class assert {} +class async {} +class await {} +class break {} +class case {} +class catch {} +class class {} +class const {} +class continue {} +class covariant {} +class default {} +class deferred {} +class do {} +class dynamic {} +class else {} +class enum {} +class export {} +class extends {} +class extension {} +class external {} +class factory {} +class false {} +class final {} +class finally {} +class for {} +class Function {} +class get {} +class hide {} +class if {} +class implements {} +class import {} +class in {} +class inout {} +class interface {} +class is {} +class late {} +class library {} +class mixin {} +class native {} +class new {} +class null {} +class of {} +class on {} +class operator {} +class out {} +class part {} +class patch {} +class required {} +class rethrow {} +class return {} +class set {} +class show {} +class source {} +class static {} +class super {} +class switch {} +class sync {} +class this {} +class throw {} +class true {} +class try {} +class typedef {} +class var {} +class void {} +class while {} +class with {} +class yield {} + + +class[KeywordToken] abstract[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] as[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] assert[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] async[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] await[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] break[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] case[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] catch[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] class[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] const[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] continue[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] covariant[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] default[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] deferred[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] do[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] dynamic[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] else[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] enum[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] export[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] extends[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] extension[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] external[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] factory[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] false[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] final[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] finally[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] for[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] Function[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] get[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] hide[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] if[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] implements[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] import[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] in[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] inout[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] interface[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] is[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] late[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] library[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] mixin[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] native[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] new[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] null[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] of[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] on[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] operator[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] out[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] part[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] patch[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] required[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] rethrow[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] return[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] set[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] show[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] source[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] static[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] super[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] switch[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] sync[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] this[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] throw[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] true[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] try[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] typedef[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] var[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] void[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] while[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] with[KeywordToken] {[BeginToken]}[SimpleToken] +class[KeywordToken] yield[KeywordToken] {[BeginToken]}[SimpleToken] +[SimpleToken] diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart new file mode 100644 index 00000000000..b70c6c34489 --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart @@ -0,0 +1,69 @@ +class abstract = A with B; +class as = A with B; +class assert = A with B; +class async = A with B; +class await = A with B; +class break = A with B; +class case = A with B; +class catch = A with B; +class class = A with B; +class const = A with B; +class continue = A with B; +class covariant = A with B; +class default = A with B; +class deferred = A with B; +class do = A with B; +class dynamic = A with B; +class else = A with B; +class enum = A with B; +class export = A with B; +class extends = A with B; +class extension = A with B; +class external = A with B; +class factory = A with B; +class false = A with B; +class final = A with B; +class finally = A with B; +class for = A with B; +class Function = A with B; +class get = A with B; +class hide = A with B; +class if = A with B; +class implements = A with B; +class import = A with B; +class in = A with B; +class inout = A with B; +class interface = A with B; +class is = A with B; +class late = A with B; +class library = A with B; +class mixin = A with B; +class native = A with B; +class new = A with B; +class null = A with B; +class of = A with B; +class on = A with B; +class operator = A with B; +class out = A with B; +class part = A with B; +class patch = A with B; +class required = A with B; +class rethrow = A with B; +class return = A with B; +class set = A with B; +class show = A with B; +class source = A with B; +class static = A with B; +class super = A with B; +class switch = A with B; +class sync = A with B; +class this = A with B; +class throw = A with B; +class true = A with B; +class try = A with B; +class typedef = A with B; +class var = A with B; +class void = A with B; +class while = A with B; +class with = A with B; +class yield = A with B; diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.expect new file mode 100644 index 00000000000..caa8b1a35ba --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.expect @@ -0,0 +1,1452 @@ +Problems reported: + +parser/error_recovery/issue_46346_prime_1:1:7: Can't use 'abstract' as a name here. +class abstract = A with B; + ^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:2:7: Can't use 'as' as a name here. +class as = A with B; + ^^ + +parser/error_recovery/issue_46346_prime_1:3:7: 'assert' can't be used as an identifier because it's a keyword. +class assert = A with B; + ^^^^^^ + +parser/error_recovery/issue_46346_prime_1:6:7: 'break' can't be used as an identifier because it's a keyword. +class break = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:7:7: 'case' can't be used as an identifier because it's a keyword. +class case = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:8:7: 'catch' can't be used as an identifier because it's a keyword. +class catch = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:9:7: 'class' can't be used as an identifier because it's a keyword. +class class = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:10:7: 'const' can't be used as an identifier because it's a keyword. +class const = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:11:7: 'continue' can't be used as an identifier because it's a keyword. +class continue = A with B; + ^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:12:7: Can't use 'covariant' as a name here. +class covariant = A with B; + ^^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:13:7: 'default' can't be used as an identifier because it's a keyword. +class default = A with B; + ^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:14:7: Can't use 'deferred' as a name here. +class deferred = A with B; + ^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:15:7: 'do' can't be used as an identifier because it's a keyword. +class do = A with B; + ^^ + +parser/error_recovery/issue_46346_prime_1:16:7: Can't use 'dynamic' as a name here. +class dynamic = A with B; + ^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:17:7: 'else' can't be used as an identifier because it's a keyword. +class else = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:18:7: 'enum' can't be used as an identifier because it's a keyword. +class enum = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:19:7: Can't use 'export' as a name here. +class export = A with B; + ^^^^^^ + +parser/error_recovery/issue_46346_prime_1:20:7: 'extends' can't be used as an identifier because it's a keyword. +class extends = A with B; + ^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:21:7: Can't use 'extension' as a name here. +class extension = A with B; + ^^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:22:7: Can't use 'external' as a name here. +class external = A with B; + ^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:23:7: Can't use 'factory' as a name here. +class factory = A with B; + ^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:24:7: 'false' can't be used as an identifier because it's a keyword. +class false = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:25:7: 'final' can't be used as an identifier because it's a keyword. +class final = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:26:7: 'finally' can't be used as an identifier because it's a keyword. +class finally = A with B; + ^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:27:7: 'for' can't be used as an identifier because it's a keyword. +class for = A with B; + ^^^ + +parser/error_recovery/issue_46346_prime_1:29:7: Can't use 'get' as a name here. +class get = A with B; + ^^^ + +parser/error_recovery/issue_46346_prime_1:31:7: 'if' can't be used as an identifier because it's a keyword. +class if = A with B; + ^^ + +parser/error_recovery/issue_46346_prime_1:32:7: Can't use 'implements' as a name here. +class implements = A with B; + ^^^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:33:7: Can't use 'import' as a name here. +class import = A with B; + ^^^^^^ + +parser/error_recovery/issue_46346_prime_1:34:7: 'in' can't be used as an identifier because it's a keyword. +class in = A with B; + ^^ + +parser/error_recovery/issue_46346_prime_1:36:7: Can't use 'interface' as a name here. +class interface = A with B; + ^^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:37:7: 'is' can't be used as an identifier because it's a keyword. +class is = A with B; + ^^ + +parser/error_recovery/issue_46346_prime_1:38:7: Can't use 'late' as a name here. +class late = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:39:7: Can't use 'library' as a name here. +class library = A with B; + ^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:40:7: Can't use 'mixin' as a name here. +class mixin = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:42:7: 'new' can't be used as an identifier because it's a keyword. +class new = A with B; + ^^^ + +parser/error_recovery/issue_46346_prime_1:43:7: 'null' can't be used as an identifier because it's a keyword. +class null = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:46:7: Can't use 'operator' as a name here. +class operator = A with B; + ^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:48:7: Can't use 'part' as a name here. +class part = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:50:7: Can't use 'required' as a name here. +class required = A with B; + ^^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:51:7: 'rethrow' can't be used as an identifier because it's a keyword. +class rethrow = A with B; + ^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:52:7: 'return' can't be used as an identifier because it's a keyword. +class return = A with B; + ^^^^^^ + +parser/error_recovery/issue_46346_prime_1:53:7: Can't use 'set' as a name here. +class set = A with B; + ^^^ + +parser/error_recovery/issue_46346_prime_1:56:7: Can't use 'static' as a name here. +class static = A with B; + ^^^^^^ + +parser/error_recovery/issue_46346_prime_1:57:7: 'super' can't be used as an identifier because it's a keyword. +class super = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:58:7: 'switch' can't be used as an identifier because it's a keyword. +class switch = A with B; + ^^^^^^ + +parser/error_recovery/issue_46346_prime_1:60:7: 'this' can't be used as an identifier because it's a keyword. +class this = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:61:7: 'throw' can't be used as an identifier because it's a keyword. +class throw = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:62:7: 'true' can't be used as an identifier because it's a keyword. +class true = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:63:7: 'try' can't be used as an identifier because it's a keyword. +class try = A with B; + ^^^ + +parser/error_recovery/issue_46346_prime_1:64:7: Can't use 'typedef' as a name here. +class typedef = A with B; + ^^^^^^^ + +parser/error_recovery/issue_46346_prime_1:65:7: 'var' can't be used as an identifier because it's a keyword. +class var = A with B; + ^^^ + +parser/error_recovery/issue_46346_prime_1:66:7: 'void' can't be used as an identifier because it's a keyword. +class void = A with B; + ^^^^ + +parser/error_recovery/issue_46346_prime_1:67:7: 'while' can't be used as an identifier because it's a keyword. +class while = A with B; + ^^^^^ + +parser/error_recovery/issue_46346_prime_1:68:7: 'with' can't be used as an identifier because it's a keyword. +class with = A with B; + ^^^^ + +beginCompilationUnit(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'abstract' as a name here., null, {lexeme: abstract}], abstract, abstract) + handleIdentifier(abstract, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, abstract) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'as' as a name here., null, {lexeme: as}], as, as) + handleIdentifier(as, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, as) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert) + handleIdentifier(assert, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, assert) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(async, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, async) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(await, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, await) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break) + handleIdentifier(break, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, break) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case) + handleIdentifier(case, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, case) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch) + handleIdentifier(catch, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, catch) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class) + handleIdentifier(class, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, class) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const) + handleIdentifier(const, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, const) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue) + handleIdentifier(continue, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, continue) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'covariant' as a name here., null, {lexeme: covariant}], covariant, covariant) + handleIdentifier(covariant, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, covariant) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default) + handleIdentifier(default, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, default) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'deferred' as a name here., null, {lexeme: deferred}], deferred, deferred) + handleIdentifier(deferred, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, deferred) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do) + handleIdentifier(do, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, do) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'dynamic' as a name here., null, {lexeme: dynamic}], dynamic, dynamic) + handleIdentifier(dynamic, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, dynamic) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else) + handleIdentifier(else, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, else) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum) + handleIdentifier(enum, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, enum) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'export' as a name here., null, {lexeme: export}], export, export) + handleIdentifier(export, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, export) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends) + handleIdentifier(extends, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, extends) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'extension' as a name here., null, {lexeme: extension}], extension, extension) + handleIdentifier(extension, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, extension) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'external' as a name here., null, {lexeme: external}], external, external) + handleIdentifier(external, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, external) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'factory' as a name here., null, {lexeme: factory}], factory, factory) + handleIdentifier(factory, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, factory) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false) + handleIdentifier(false, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, false) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final) + handleIdentifier(final, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, final) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally) + handleIdentifier(finally, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, finally) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for) + handleIdentifier(for, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, for) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(Function, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, Function) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'get' as a name here., null, {lexeme: get}], get, get) + handleIdentifier(get, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, get) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(hide, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, hide) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if) + handleIdentifier(if, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, if) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'implements' as a name here., null, {lexeme: implements}], implements, implements) + handleIdentifier(implements, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, implements) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'import' as a name here., null, {lexeme: import}], import, import) + handleIdentifier(import, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, import) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in) + handleIdentifier(in, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, in) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(inout, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, inout) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'interface' as a name here., null, {lexeme: interface}], interface, interface) + handleIdentifier(interface, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, interface) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is) + handleIdentifier(is, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, is) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'late' as a name here., null, {lexeme: late}], late, late) + handleIdentifier(late, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, late) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'library' as a name here., null, {lexeme: library}], library, library) + handleIdentifier(library, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, library) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'mixin' as a name here., null, {lexeme: mixin}], mixin, mixin) + handleIdentifier(mixin, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, mixin) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(native, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, native) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new) + handleIdentifier(new, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, new) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null) + handleIdentifier(null, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, null) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(of, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, of) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(on, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, on) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'operator' as a name here., null, {lexeme: operator}], operator, operator) + handleIdentifier(operator, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, operator) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(out, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, out) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'part' as a name here., null, {lexeme: part}], part, part) + handleIdentifier(part, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, part) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(patch, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, patch) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'required' as a name here., null, {lexeme: required}], required, required) + handleIdentifier(required, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, required) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow) + handleIdentifier(rethrow, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, rethrow) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return) + handleIdentifier(return, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, return) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'set' as a name here., null, {lexeme: set}], set, set) + handleIdentifier(set, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, set) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(show, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, show) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(source, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, source) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'static' as a name here., null, {lexeme: static}], static, static) + handleIdentifier(static, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, static) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super) + handleIdentifier(super, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, super) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch) + handleIdentifier(switch, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, switch) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(sync, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, sync) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this) + handleIdentifier(this, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, this) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw) + handleIdentifier(throw, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, throw) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true) + handleIdentifier(true, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, true) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try) + handleIdentifier(try, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, try) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'typedef' as a name here., null, {lexeme: typedef}], typedef, typedef) + handleIdentifier(typedef, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, typedef) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var) + handleIdentifier(var, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, var) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void) + handleIdentifier(void, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, void) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while) + handleIdentifier(while, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, while) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with) + handleIdentifier(with, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, with) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleIdentifier(yield, classOrMixinDeclaration) + handleNoTypeVariables(=) + beginNamedMixinApplication(class, null, yield) + handleIdentifier(A, typeReference) + handleNoTypeArguments(with) + handleType(A, null) + beginTypeList(B) + handleIdentifier(B, typeReference) + handleNoTypeArguments(;) + handleType(B, null) + endTypeList(1) + handleNamedMixinApplicationWithClause(with) + endNamedMixinApplication(class, class, =, null, ;) + endTopLevelDeclaration() +endCompilationUnit(69, ) diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.intertwined.expect new file mode 100644 index 00000000000..d0f33a64f96 --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.intertwined.expect @@ -0,0 +1,1979 @@ +parseUnit(class) + skipErrorTokens(class) + listener: beginCompilationUnit(class) + syntheticPreviousToken(class) + parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext') + parseMetadataStar() + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(abstract, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'abstract' as a name here., null, {lexeme: abstract}], abstract, abstract) + listener: handleIdentifier(abstract, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, abstract) + parseNamedMixinApplication(abstract, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(as, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'as' as a name here., null, {lexeme: as}], as, as) + listener: handleIdentifier(as, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, as) + parseNamedMixinApplication(as, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(assert, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert) + listener: handleIdentifier(assert, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, assert) + parseNamedMixinApplication(assert, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(async, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, async) + parseNamedMixinApplication(async, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(await, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, await) + parseNamedMixinApplication(await, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break) + listener: handleIdentifier(break, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, break) + parseNamedMixinApplication(break, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case) + listener: handleIdentifier(case, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, case) + parseNamedMixinApplication(case, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch) + listener: handleIdentifier(catch, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, catch) + parseNamedMixinApplication(catch, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class) + listener: handleIdentifier(class, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, class) + parseNamedMixinApplication(class, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(const, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const) + listener: handleIdentifier(const, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, const) + parseNamedMixinApplication(const, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue) + listener: handleIdentifier(continue, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, continue) + parseNamedMixinApplication(continue, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(covariant, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'covariant' as a name here., null, {lexeme: covariant}], covariant, covariant) + listener: handleIdentifier(covariant, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, covariant) + parseNamedMixinApplication(covariant, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default) + listener: handleIdentifier(default, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, default) + parseNamedMixinApplication(default, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(deferred, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'deferred' as a name here., null, {lexeme: deferred}], deferred, deferred) + listener: handleIdentifier(deferred, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, deferred) + parseNamedMixinApplication(deferred, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do) + listener: handleIdentifier(do, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, do) + parseNamedMixinApplication(do, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(dynamic, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'dynamic' as a name here., null, {lexeme: dynamic}], dynamic, dynamic) + listener: handleIdentifier(dynamic, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, dynamic) + parseNamedMixinApplication(dynamic, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else) + listener: handleIdentifier(else, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, else) + parseNamedMixinApplication(else, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum) + listener: handleIdentifier(enum, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, enum) + parseNamedMixinApplication(enum, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(export, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'export' as a name here., null, {lexeme: export}], export, export) + listener: handleIdentifier(export, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, export) + parseNamedMixinApplication(export, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends) + listener: handleIdentifier(extends, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, extends) + parseNamedMixinApplication(extends, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(extension, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'extension' as a name here., null, {lexeme: extension}], extension, extension) + listener: handleIdentifier(extension, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, extension) + parseNamedMixinApplication(extension, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(external, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'external' as a name here., null, {lexeme: external}], external, external) + listener: handleIdentifier(external, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, external) + parseNamedMixinApplication(external, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(factory, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'factory' as a name here., null, {lexeme: factory}], factory, factory) + listener: handleIdentifier(factory, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, factory) + parseNamedMixinApplication(factory, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(false, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false) + listener: handleIdentifier(false, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, false) + parseNamedMixinApplication(false, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final) + listener: handleIdentifier(final, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, final) + parseNamedMixinApplication(final, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally) + listener: handleIdentifier(finally, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, finally) + parseNamedMixinApplication(finally, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for) + listener: handleIdentifier(for, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, for) + parseNamedMixinApplication(for, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(Function, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, Function) + parseNamedMixinApplication(Function, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(get, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'get' as a name here., null, {lexeme: get}], get, get) + listener: handleIdentifier(get, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, get) + parseNamedMixinApplication(get, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(hide, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, hide) + parseNamedMixinApplication(hide, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if) + listener: handleIdentifier(if, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, if) + parseNamedMixinApplication(if, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(implements, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'implements' as a name here., null, {lexeme: implements}], implements, implements) + listener: handleIdentifier(implements, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, implements) + parseNamedMixinApplication(implements, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(import, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'import' as a name here., null, {lexeme: import}], import, import) + listener: handleIdentifier(import, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, import) + parseNamedMixinApplication(import, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in) + listener: handleIdentifier(in, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, in) + parseNamedMixinApplication(in, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(inout, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, inout) + parseNamedMixinApplication(inout, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(interface, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'interface' as a name here., null, {lexeme: interface}], interface, interface) + listener: handleIdentifier(interface, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, interface) + parseNamedMixinApplication(interface, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is) + listener: handleIdentifier(is, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, is) + parseNamedMixinApplication(is, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(late, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'late' as a name here., null, {lexeme: late}], late, late) + listener: handleIdentifier(late, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, late) + parseNamedMixinApplication(late, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(library, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'library' as a name here., null, {lexeme: library}], library, library) + listener: handleIdentifier(library, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, library) + parseNamedMixinApplication(library, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(mixin, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'mixin' as a name here., null, {lexeme: mixin}], mixin, mixin) + listener: handleIdentifier(mixin, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, mixin) + parseNamedMixinApplication(mixin, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(native, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, native) + parseNamedMixinApplication(native, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(new, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new) + listener: handleIdentifier(new, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, new) + parseNamedMixinApplication(new, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(null, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null) + listener: handleIdentifier(null, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, null) + parseNamedMixinApplication(null, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(of, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, of) + parseNamedMixinApplication(of, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(on, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, on) + parseNamedMixinApplication(on, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(operator, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'operator' as a name here., null, {lexeme: operator}], operator, operator) + listener: handleIdentifier(operator, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, operator) + parseNamedMixinApplication(operator, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(out, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, out) + parseNamedMixinApplication(out, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(part, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'part' as a name here., null, {lexeme: part}], part, part) + listener: handleIdentifier(part, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, part) + parseNamedMixinApplication(part, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(patch, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, patch) + parseNamedMixinApplication(patch, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(required, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'required' as a name here., null, {lexeme: required}], required, required) + listener: handleIdentifier(required, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, required) + parseNamedMixinApplication(required, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow) + listener: handleIdentifier(rethrow, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, rethrow) + parseNamedMixinApplication(rethrow, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return) + listener: handleIdentifier(return, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, return) + parseNamedMixinApplication(return, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(set, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'set' as a name here., null, {lexeme: set}], set, set) + listener: handleIdentifier(set, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, set) + parseNamedMixinApplication(set, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(show, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, show) + parseNamedMixinApplication(show, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(source, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, source) + parseNamedMixinApplication(source, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(static, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'static' as a name here., null, {lexeme: static}], static, static) + listener: handleIdentifier(static, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, static) + parseNamedMixinApplication(static, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(super, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super) + listener: handleIdentifier(super, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, super) + parseNamedMixinApplication(super, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch) + listener: handleIdentifier(switch, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, switch) + parseNamedMixinApplication(switch, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(sync, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, sync) + parseNamedMixinApplication(sync, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(this, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this) + listener: handleIdentifier(this, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, this) + parseNamedMixinApplication(this, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(throw, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw) + listener: handleIdentifier(throw, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, throw) + parseNamedMixinApplication(throw, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(true, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true) + listener: handleIdentifier(true, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, true) + parseNamedMixinApplication(true, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try) + listener: handleIdentifier(try, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, try) + parseNamedMixinApplication(try, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(typedef, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'typedef' as a name here., null, {lexeme: typedef}], typedef, typedef) + listener: handleIdentifier(typedef, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, typedef) + parseNamedMixinApplication(typedef, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var) + listener: handleIdentifier(var, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, var) + parseNamedMixinApplication(var, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void) + listener: handleIdentifier(void, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, void) + parseNamedMixinApplication(void, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while) + listener: handleIdentifier(while, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, while) + parseNamedMixinApplication(while, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>') + listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with) + listener: handleIdentifier(with, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, with) + parseNamedMixinApplication(with, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration(class) + parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext') + parseMetadataStar(;) + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(;, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(;, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + listener: handleIdentifier(yield, classOrMixinDeclaration) + listener: handleNoTypeVariables(=) + listener: beginNamedMixinApplication(class, null, yield) + parseNamedMixinApplication(yield, class, class) + listener: handleIdentifier(A, typeReference) + listener: handleNoTypeArguments(with) + listener: handleType(A, null) + parseMixinApplicationRest(A) + parseTypeList(with) + listener: beginTypeList(B) + listener: handleIdentifier(B, typeReference) + listener: handleNoTypeArguments(;) + listener: handleType(B, null) + listener: endTypeList(1) + listener: handleNamedMixinApplicationWithClause(with) + ensureSemicolon(B) + listener: endNamedMixinApplication(class, class, =, null, ;) + listener: endTopLevelDeclaration() + reportAllErrorTokens(class) + listener: endCompilationUnit(69, ) diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.parser.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.parser.expect new file mode 100644 index 00000000000..049b7d100ed --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.parser.expect @@ -0,0 +1,141 @@ +class abstract = A with B; +class as = A with B; +class assert = A with B; +class async = A with B; +class await = A with B; +class break = A with B; +class case = A with B; +class catch = A with B; +class class = A with B; +class const = A with B; +class continue = A with B; +class covariant = A with B; +class default = A with B; +class deferred = A with B; +class do = A with B; +class dynamic = A with B; +class else = A with B; +class enum = A with B; +class export = A with B; +class extends = A with B; +class extension = A with B; +class external = A with B; +class factory = A with B; +class false = A with B; +class final = A with B; +class finally = A with B; +class for = A with B; +class Function = A with B; +class get = A with B; +class hide = A with B; +class if = A with B; +class implements = A with B; +class import = A with B; +class in = A with B; +class inout = A with B; +class interface = A with B; +class is = A with B; +class late = A with B; +class library = A with B; +class mixin = A with B; +class native = A with B; +class new = A with B; +class null = A with B; +class of = A with B; +class on = A with B; +class operator = A with B; +class out = A with B; +class part = A with B; +class patch = A with B; +class required = A with B; +class rethrow = A with B; +class return = A with B; +class set = A with B; +class show = A with B; +class source = A with B; +class static = A with B; +class super = A with B; +class switch = A with B; +class sync = A with B; +class this = A with B; +class throw = A with B; +class true = A with B; +class try = A with B; +class typedef = A with B; +class var = A with B; +class void = A with B; +class while = A with B; +class with = A with B; +class yield = A with B; + + +class[KeywordToken] abstract[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] as[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] assert[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] async[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] await[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] break[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] case[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] catch[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] class[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] const[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] continue[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] covariant[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] default[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] deferred[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] do[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] dynamic[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] else[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] enum[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] export[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] extends[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] extension[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] external[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] factory[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] false[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] final[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] finally[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] for[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] Function[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] get[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] hide[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] if[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] implements[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] import[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] in[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] inout[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] interface[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] is[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] late[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] library[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] mixin[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] native[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] new[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] null[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] of[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] on[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] operator[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] out[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] part[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] patch[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] required[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] rethrow[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] return[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] set[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] show[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] source[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] static[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] super[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] switch[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] sync[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] this[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] throw[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] true[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] try[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] typedef[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] var[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] void[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] while[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] with[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] yield[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +[SimpleToken] diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.scanner.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.scanner.expect new file mode 100644 index 00000000000..049b7d100ed --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.scanner.expect @@ -0,0 +1,141 @@ +class abstract = A with B; +class as = A with B; +class assert = A with B; +class async = A with B; +class await = A with B; +class break = A with B; +class case = A with B; +class catch = A with B; +class class = A with B; +class const = A with B; +class continue = A with B; +class covariant = A with B; +class default = A with B; +class deferred = A with B; +class do = A with B; +class dynamic = A with B; +class else = A with B; +class enum = A with B; +class export = A with B; +class extends = A with B; +class extension = A with B; +class external = A with B; +class factory = A with B; +class false = A with B; +class final = A with B; +class finally = A with B; +class for = A with B; +class Function = A with B; +class get = A with B; +class hide = A with B; +class if = A with B; +class implements = A with B; +class import = A with B; +class in = A with B; +class inout = A with B; +class interface = A with B; +class is = A with B; +class late = A with B; +class library = A with B; +class mixin = A with B; +class native = A with B; +class new = A with B; +class null = A with B; +class of = A with B; +class on = A with B; +class operator = A with B; +class out = A with B; +class part = A with B; +class patch = A with B; +class required = A with B; +class rethrow = A with B; +class return = A with B; +class set = A with B; +class show = A with B; +class source = A with B; +class static = A with B; +class super = A with B; +class switch = A with B; +class sync = A with B; +class this = A with B; +class throw = A with B; +class true = A with B; +class try = A with B; +class typedef = A with B; +class var = A with B; +class void = A with B; +class while = A with B; +class with = A with B; +class yield = A with B; + + +class[KeywordToken] abstract[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] as[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] assert[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] async[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] await[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] break[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] case[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] catch[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] class[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] const[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] continue[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] covariant[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] default[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] deferred[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] do[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] dynamic[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] else[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] enum[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] export[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] extends[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] extension[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] external[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] factory[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] false[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] final[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] finally[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] for[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] Function[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] get[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] hide[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] if[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] implements[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] import[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] in[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] inout[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] interface[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] is[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] late[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] library[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] mixin[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] native[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] new[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] null[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] of[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] on[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] operator[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] out[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] part[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] patch[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] required[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] rethrow[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] return[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] set[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] show[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] source[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] static[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] super[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] switch[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] sync[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] this[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] throw[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] true[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] try[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] typedef[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] var[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] void[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] while[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] with[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +class[KeywordToken] yield[KeywordToken] =[SimpleToken] A[StringToken] with[KeywordToken] B[StringToken];[SimpleToken] +[SimpleToken] diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart new file mode 100644 index 00000000000..1e88aff85f6 --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart @@ -0,0 +1 @@ +class \ No newline at end of file diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.expect new file mode 100644 index 00000000000..86afa58b054 --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.expect @@ -0,0 +1,40 @@ +Problems reported: + +parser/error_recovery/issue_46346_prime_2:1:6: Expected an identifier, but got ''. +class + ^... + +WARNING: Reporting at eof --- see below for details. + +parser/error_recovery/issue_46346_prime_2:1:6: A class declaration must have a body, even if it is empty. +class + ^... + +WARNING: Reporting at eof --- see below for details. + +beginCompilationUnit(class) + beginMetadataStar(class) + endMetadataStar(0) + beginClassOrNamedMixinApplicationPrelude(class) + handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ''., Try inserting an identifier before ''., {lexeme: }], , ) + // WARNING: Reporting at eof for . + handleIdentifier(, classOrMixinDeclaration) + handleNoTypeVariables() + beginClassDeclaration(class, null, ) + handleNoType() + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleClassHeader(class, class, null) + handleNoType() + handleClassExtends(null, 1) + handleClassNoWithClause() + handleClassOrMixinImplements(null, 0) + handleRecoverClassHeader() + handleRecoverableError(Message[ExpectedClassOrMixinBody, A class declaration must have a body, even if it is empty., Try adding an empty body., {string: class declaration}], , ) + // WARNING: Reporting at eof for . + beginClassOrMixinBody(DeclarationKind.Class, {) + endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + endClassDeclaration(class, }) + endTopLevelDeclaration() +endCompilationUnit(1, ) diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.intertwined.expect new file mode 100644 index 00000000000..766bdc30d5a --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.intertwined.expect @@ -0,0 +1,60 @@ +parseUnit(class) + skipErrorTokens(class) + listener: beginCompilationUnit(class) + syntheticPreviousToken(class) + parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext') + parseMetadataStar() + listener: beginMetadataStar(class) + listener: endMetadataStar(0) + parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext') + parseClassDeclarationModifiers(, class) + parseClassOrNamedMixinApplication(null, class) + listener: beginClassOrNamedMixinApplicationPrelude(class) + ensureIdentifier(class, classOrMixinDeclaration) + insertSyntheticIdentifier(class, classOrMixinDeclaration, message: Message[ExpectedIdentifier, Expected an identifier, but got ''., Try inserting an identifier before ''., {lexeme: }], messageOnToken: null) + reportRecoverableError(, Message[ExpectedIdentifier, Expected an identifier, but got ''., Try inserting an identifier before ''., {lexeme: }]) + listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ''., Try inserting an identifier before ''., {lexeme: }], , ) + listener: // WARNING: Reporting at eof for . + rewriter() + listener: handleIdentifier(, classOrMixinDeclaration) + listener: handleNoTypeVariables() + listener: beginClassDeclaration(class, null, ) + parseClass(, class, class, ) + parseClassHeaderOpt(, class, class) + parseClassExtendsOpt() + listener: handleNoType() + listener: handleClassExtends(null, 1) + parseWithClauseOpt() + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt() + listener: handleClassOrMixinImplements(null, 0) + listener: handleClassHeader(class, class, null) + parseClassHeaderRecovery(, class, class) + parseClassHeaderOpt(, class, class) + parseClassExtendsOpt() + parseWithClauseOpt() + parseClassOrMixinImplementsOpt() + skipUnexpectedTokenOpt(, [extends, with, implements, {]) + parseClassExtendsOpt() + listener: handleNoType() + listener: handleClassExtends(null, 1) + parseWithClauseOpt() + listener: handleClassNoWithClause() + parseClassOrMixinImplementsOpt() + listener: handleClassOrMixinImplements(null, 0) + listener: handleRecoverClassHeader() + ensureBlock(, null, class declaration) + reportRecoverableError(, Message[ExpectedClassOrMixinBody, A class declaration must have a body, even if it is empty., Try adding an empty body., {string: class declaration}]) + listener: handleRecoverableError(Message[ExpectedClassOrMixinBody, A class declaration must have a body, even if it is empty., Try adding an empty body., {string: class declaration}], , ) + listener: // WARNING: Reporting at eof for . + insertBlock() + rewriter() + rewriter() + parseClassOrMixinOrExtensionBody(, DeclarationKind.Class, ) + listener: beginClassOrMixinBody(DeclarationKind.Class, {) + notEofOrValue(}, }) + listener: endClassOrMixinBody(DeclarationKind.Class, 0, {, }) + listener: endClassDeclaration(class, }) + listener: endTopLevelDeclaration() + reportAllErrorTokens(class) + listener: endCompilationUnit(1, ) diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.parser.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.parser.expect new file mode 100644 index 00000000000..6294f83a81e --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.parser.expect @@ -0,0 +1,5 @@ +NOTICE: Stream was rewritten by parser! + +class{} + +class[KeywordToken][SyntheticStringToken]{[SyntheticBeginToken]}[SyntheticToken][SimpleToken] diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.scanner.expect b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.scanner.expect new file mode 100644 index 00000000000..dedca4c98aa --- /dev/null +++ b/pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.scanner.expect @@ -0,0 +1,3 @@ +class + +class[KeywordToken][SimpleToken] diff --git a/tests/language/identifier/built_in_illegal_test.dart b/tests/language/identifier/built_in_illegal_test.dart index 12be975cb80..0fd6336fb88 100644 --- a/tests/language/identifier/built_in_illegal_test.dart +++ b/tests/language/identifier/built_in_illegal_test.dart @@ -18,24 +18,8 @@ class dynamic { } // [cfe] Can't use 'dynamic' as a name here. class export { } // ^^^^^^ -// [analyzer] SYNTACTIC_ERROR.DIRECTIVE_AFTER_DECLARATION -// [cfe] A class declaration must have a body, even if it is empty. -// ^^^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [cfe] Directives must appear before any declarations. -// ^^^^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'export'. -// [error line 19, column 14, length 0] -// [cfe] Expected ';' after this. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [cfe] Expected a String, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_STRING_LITERAL -// [cfe] Expected a declaration, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'export' as a name here. class external { } // ^^^^^^^^ // [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION @@ -46,132 +30,47 @@ class factory { } // [cfe] Can't use 'factory' as a name here. class get { } // ^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [cfe] A class declaration must have a body, even if it is empty. -// ^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_FUNCTION_PARAMETERS -// [cfe] A function declaration needs an explicit list of parameters. -// ^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'get'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'get' as a name here. class interface { } // ^^^^^^^^^ // [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION // [cfe] Can't use 'interface' as a name here. class implements { } // ^^^^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'implements'. -// [error line 61, column 18, length 0] -// [analyzer] COMPILE_TIME_ERROR.IMPLEMENTS_NON_CLASS -// [cfe] Expected a type, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TYPE_NAME +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'implements' as a name here. class import { } // ^^^^^^ -// [analyzer] SYNTACTIC_ERROR.DIRECTIVE_AFTER_DECLARATION -// [cfe] A class declaration must have a body, even if it is empty. -// ^^^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [cfe] Directives must appear before any declarations. -// ^^^^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'import'. -// [error line 70, column 14, length 0] -// [cfe] Expected ';' after this. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [cfe] Expected a String, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_STRING_LITERAL -// [cfe] Expected a declaration, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'import' as a name here. class mixin { } // ^^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [cfe] A class declaration must have a body, even if it is empty. -// ^^^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'mixin'. -// ^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got '{'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'mixin' as a name here. class library { } // ^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [cfe] A class declaration must have a body, even if it is empty. -// ^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.LIBRARY_DIRECTIVE_NOT_FIRST -// [cfe] Expected an identifier, but got 'library'. -// ^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] The library directive must appear before all other directives. -// ^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [cfe] Expected ';' after this. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN -// [cfe] Expected a declaration, but got '}'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'library' as a name here. class operator { } // ^^^^^^^^ // [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION // [cfe] Can't use 'operator' as a name here. class part { } // ^^^^ -// [analyzer] SYNTACTIC_ERROR.DIRECTIVE_AFTER_DECLARATION -// [cfe] A class declaration must have a body, even if it is empty. -// ^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [cfe] Directives must appear before any declarations. -// ^^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'part'. -// [error line 123, column 12, length 0] -// [cfe] Expected ';' after this. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [cfe] Expected a String, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_STRING_LITERAL -// [cfe] Expected a declaration, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'part' as a name here. class set { } // ^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [cfe] A class declaration must have a body, even if it is empty. -// ^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_FUNCTION_PARAMETERS -// [cfe] A function declaration needs an explicit list of parameters. -// ^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'set'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'set' as a name here. class static { } // ^^^^^^ // [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION // [cfe] Can't use 'static' as a name here. class typedef { } // ^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [cfe] A class declaration must have a body, even if it is empty. -// ^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'typedef'. -// ^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [cfe] A typedef needs an explicit list of parameters. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN -// [cfe] Expected ';' after this. -// ^ -// [analyzer] SYNTACTIC_ERROR.MISSING_TYPEDEF_PARAMETERS -// [cfe] Expected a declaration, but got '}'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'typedef' as a name here. main() {} diff --git a/tests/language_2/identifier/built_in_illegal_test.dart b/tests/language_2/identifier/built_in_illegal_test.dart index 822bfc95419..652199e8aeb 100644 --- a/tests/language_2/identifier/built_in_illegal_test.dart +++ b/tests/language_2/identifier/built_in_illegal_test.dart @@ -20,19 +20,8 @@ class dynamic { } // [cfe] Can't use 'dynamic' as a name here. class export { } // ^^^^^^ -// [analyzer] SYNTACTIC_ERROR.DIRECTIVE_AFTER_DECLARATION -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] A class declaration must have a body, even if it is empty. -// [cfe] Directives must appear before any declarations. -// [cfe] Expected an identifier, but got 'export'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [analyzer] SYNTACTIC_ERROR.EXPECTED_STRING_LITERAL -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN -// [cfe] Expected ';' after this. -// [cfe] Expected a String, but got '{'. -// [cfe] Expected a declaration, but got '{'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'export' as a name here. class external { } // ^^^^^^^^ // [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION @@ -43,111 +32,47 @@ class factory { } // [cfe] Can't use 'factory' as a name here. class get { } // ^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [analyzer] SYNTACTIC_ERROR.MISSING_FUNCTION_PARAMETERS -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] A class declaration must have a body, even if it is empty. -// [cfe] A function declaration needs an explicit list of parameters. -// [cfe] Expected an identifier, but got 'get'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'get' as a name here. class interface { } // ^^^^^^^^^ // [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION // [cfe] Can't use 'interface' as a name here. class implements { } // ^^^^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got 'implements'. -// [error line 56, column 18, length 0] -// [analyzer] COMPILE_TIME_ERROR.IMPLEMENTS_NON_CLASS -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TYPE_NAME -// [cfe] Expected a type, but got '{'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'implements' as a name here. class import { } // ^^^^^^ -// [analyzer] SYNTACTIC_ERROR.DIRECTIVE_AFTER_DECLARATION -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] A class declaration must have a body, even if it is empty. -// [cfe] Directives must appear before any declarations. -// [cfe] Expected an identifier, but got 'import'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [analyzer] SYNTACTIC_ERROR.EXPECTED_STRING_LITERAL -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN -// [cfe] Expected ';' after this. -// [cfe] Expected a String, but got '{'. -// [cfe] Expected a declaration, but got '{'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'import' as a name here. class mixin { } // ^^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] A class declaration must have a body, even if it is empty. -// [cfe] Expected an identifier, but got 'mixin'. -// ^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got '{'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'mixin' as a name here. class library { } // ^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [analyzer] SYNTACTIC_ERROR.LIBRARY_DIRECTIVE_NOT_FIRST -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] A class declaration must have a body, even if it is empty. -// [cfe] Expected an identifier, but got 'library'. -// [cfe] The library directive must appear before all other directives. -// ^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN -// [cfe] Expected ';' after this. -// [cfe] Expected a declaration, but got '}'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'library' as a name here. class operator { } // ^^^^^^^^ // [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION // [cfe] Can't use 'operator' as a name here. class part { } // ^^^^ -// [analyzer] SYNTACTIC_ERROR.DIRECTIVE_AFTER_DECLARATION -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] A class declaration must have a body, even if it is empty. -// [cfe] Directives must appear before any declarations. -// [cfe] Expected an identifier, but got 'part'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [analyzer] SYNTACTIC_ERROR.EXPECTED_STRING_LITERAL -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN -// [cfe] Expected ';' after this. -// [cfe] Expected a String, but got '{'. -// [cfe] Expected a declaration, but got '{'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'part' as a name here. class set { } // ^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [analyzer] SYNTACTIC_ERROR.MISSING_FUNCTION_PARAMETERS -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] A class declaration must have a body, even if it is empty. -// [cfe] A function declaration needs an explicit list of parameters. -// [cfe] Expected an identifier, but got 'set'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'set' as a name here. class static { } // ^^^^^^ // [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION // [cfe] Can't use 'static' as a name here. class typedef { } // ^^^^^^^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_BODY -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] A class declaration must have a body, even if it is empty. -// [cfe] Expected an identifier, but got 'typedef'. -// ^ -// [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER -// [cfe] Expected an identifier, but got '{'. -// ^ -// [analyzer] SYNTACTIC_ERROR.EXPECTED_EXECUTABLE -// [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN -// [analyzer] SYNTACTIC_ERROR.MISSING_TYPEDEF_PARAMETERS -// [cfe] A typedef needs an explicit list of parameters. -// [cfe] Expected ';' after this. -// [cfe] Expected a declaration, but got '}'. +// [analyzer] COMPILE_TIME_ERROR.BUILT_IN_IDENTIFIER_IN_DECLARATION +// [cfe] Can't use 'typedef' as a name here. main() {}