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