| 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, ) |
