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