Problems reported:

parser/error_recovery/issue_46346:1:7: Can't use 'abstract' as a name here.
class abstract {}
      ^^^^^^^^

parser/error_recovery/issue_46346:2:7: Can't use 'as' as a name here.
class as {}
      ^^

parser/error_recovery/issue_46346:3:7: 'assert' can't be used as an identifier because it's a keyword.
class assert {}
      ^^^^^^

parser/error_recovery/issue_46346:6:7: 'break' can't be used as an identifier because it's a keyword.
class break {}
      ^^^^^

parser/error_recovery/issue_46346:7:7: 'case' can't be used as an identifier because it's a keyword.
class case {}
      ^^^^

parser/error_recovery/issue_46346:8:7: 'catch' can't be used as an identifier because it's a keyword.
class catch {}
      ^^^^^

parser/error_recovery/issue_46346:9:7: 'class' can't be used as an identifier because it's a keyword.
class class {}
      ^^^^^

parser/error_recovery/issue_46346:10:7: 'const' can't be used as an identifier because it's a keyword.
class const {}
      ^^^^^

parser/error_recovery/issue_46346:11:7: 'continue' can't be used as an identifier because it's a keyword.
class continue {}
      ^^^^^^^^

parser/error_recovery/issue_46346:12:7: Can't use 'covariant' as a name here.
class covariant {}
      ^^^^^^^^^

parser/error_recovery/issue_46346:13:7: 'default' can't be used as an identifier because it's a keyword.
class default {}
      ^^^^^^^

parser/error_recovery/issue_46346:14:7: Can't use 'deferred' as a name here.
class deferred {}
      ^^^^^^^^

parser/error_recovery/issue_46346:15:7: 'do' can't be used as an identifier because it's a keyword.
class do {}
      ^^

parser/error_recovery/issue_46346:16:7: Can't use 'dynamic' as a name here.
class dynamic {}
      ^^^^^^^

parser/error_recovery/issue_46346:17:7: 'else' can't be used as an identifier because it's a keyword.
class else {}
      ^^^^

parser/error_recovery/issue_46346:18:7: 'enum' can't be used as an identifier because it's a keyword.
class enum {}
      ^^^^

parser/error_recovery/issue_46346:19:7: Can't use 'export' as a name here.
class export {}
      ^^^^^^

parser/error_recovery/issue_46346:20:7: 'extends' can't be used as an identifier because it's a keyword.
class extends {}
      ^^^^^^^

parser/error_recovery/issue_46346:21:7: Can't use 'extension' as a name here.
class extension {}
      ^^^^^^^^^

parser/error_recovery/issue_46346:22:7: Can't use 'external' as a name here.
class external {}
      ^^^^^^^^

parser/error_recovery/issue_46346:23:7: Can't use 'factory' as a name here.
class factory {}
      ^^^^^^^

parser/error_recovery/issue_46346:24:7: 'false' can't be used as an identifier because it's a keyword.
class false {}
      ^^^^^

parser/error_recovery/issue_46346:25:7: 'final' can't be used as an identifier because it's a keyword.
class final {}
      ^^^^^

parser/error_recovery/issue_46346:26:7: 'finally' can't be used as an identifier because it's a keyword.
class finally {}
      ^^^^^^^

parser/error_recovery/issue_46346:27:7: 'for' can't be used as an identifier because it's a keyword.
class for {}
      ^^^

parser/error_recovery/issue_46346:29:7: Can't use 'get' as a name here.
class get {}
      ^^^

parser/error_recovery/issue_46346:31:7: 'if' can't be used as an identifier because it's a keyword.
class if {}
      ^^

parser/error_recovery/issue_46346:32:7: Can't use 'implements' as a name here.
class implements {}
      ^^^^^^^^^^

parser/error_recovery/issue_46346:33:7: Can't use 'import' as a name here.
class import {}
      ^^^^^^

parser/error_recovery/issue_46346:34:7: 'in' can't be used as an identifier because it's a keyword.
class in {}
      ^^

parser/error_recovery/issue_46346:36:7: Can't use 'interface' as a name here.
class interface {}
      ^^^^^^^^^

parser/error_recovery/issue_46346:37:7: 'is' can't be used as an identifier because it's a keyword.
class is {}
      ^^

parser/error_recovery/issue_46346:38:7: Can't use 'late' as a name here.
class late {}
      ^^^^

parser/error_recovery/issue_46346:39:7: Can't use 'library' as a name here.
class library {}
      ^^^^^^^

parser/error_recovery/issue_46346:40:7: Can't use 'mixin' as a name here.
class mixin {}
      ^^^^^

parser/error_recovery/issue_46346:42:7: 'new' can't be used as an identifier because it's a keyword.
class new {}
      ^^^

parser/error_recovery/issue_46346:43:7: 'null' can't be used as an identifier because it's a keyword.
class null {}
      ^^^^

parser/error_recovery/issue_46346:46:7: Can't use 'operator' as a name here.
class operator {}
      ^^^^^^^^

parser/error_recovery/issue_46346:48:7: Can't use 'part' as a name here.
class part {}
      ^^^^

parser/error_recovery/issue_46346:50:7: Can't use 'required' as a name here.
class required {}
      ^^^^^^^^

parser/error_recovery/issue_46346:51:7: 'rethrow' can't be used as an identifier because it's a keyword.
class rethrow {}
      ^^^^^^^

parser/error_recovery/issue_46346:52:7: 'return' can't be used as an identifier because it's a keyword.
class return {}
      ^^^^^^

parser/error_recovery/issue_46346:53:7: Can't use 'set' as a name here.
class set {}
      ^^^

parser/error_recovery/issue_46346:56:7: Can't use 'static' as a name here.
class static {}
      ^^^^^^

parser/error_recovery/issue_46346:57:7: 'super' can't be used as an identifier because it's a keyword.
class super {}
      ^^^^^

parser/error_recovery/issue_46346:58:7: 'switch' can't be used as an identifier because it's a keyword.
class switch {}
      ^^^^^^

parser/error_recovery/issue_46346:60:7: 'this' can't be used as an identifier because it's a keyword.
class this {}
      ^^^^

parser/error_recovery/issue_46346:61:7: 'throw' can't be used as an identifier because it's a keyword.
class throw {}
      ^^^^^

parser/error_recovery/issue_46346:62:7: 'true' can't be used as an identifier because it's a keyword.
class true {}
      ^^^^

parser/error_recovery/issue_46346:63:7: 'try' can't be used as an identifier because it's a keyword.
class try {}
      ^^^

parser/error_recovery/issue_46346:64:7: Can't use 'typedef' as a name here.
class typedef {}
      ^^^^^^^

parser/error_recovery/issue_46346:65:7: 'var' can't be used as an identifier because it's a keyword.
class var {}
      ^^^

parser/error_recovery/issue_46346:66:7: 'void' can't be used as an identifier because it's a keyword.
class void {}
      ^^^^

parser/error_recovery/issue_46346:67:7: 'while' can't be used as an identifier because it's a keyword.
class while {}
      ^^^^^

parser/error_recovery/issue_46346:68:7: 'with' can't be used as an identifier because it's a keyword.
class with {}
      ^^^^

beginCompilationUnit(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'abstract' as a name here., null, {lexeme: abstract}], abstract, abstract)
    handleIdentifier(abstract, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, abstract)
      handleNoType(abstract)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'as' as a name here., null, {lexeme: as}], as, as)
    handleIdentifier(as, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, as)
      handleNoType(as)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert)
    handleIdentifier(assert, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, assert)
      handleNoType(assert)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(async, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, async)
      handleNoType(async)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(await, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, await)
      handleNoType(await)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break)
    handleIdentifier(break, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, break)
      handleNoType(break)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
    handleIdentifier(case, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, case)
      handleNoType(case)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
    handleIdentifier(catch, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, catch)
      handleNoType(catch)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
    handleIdentifier(class, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, class)
      handleNoType(class)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const)
    handleIdentifier(const, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, const)
      handleNoType(const)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue)
    handleIdentifier(continue, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, continue)
      handleNoType(continue)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'covariant' as a name here., null, {lexeme: covariant}], covariant, covariant)
    handleIdentifier(covariant, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, covariant)
      handleNoType(covariant)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
    handleIdentifier(default, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, default)
      handleNoType(default)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'deferred' as a name here., null, {lexeme: deferred}], deferred, deferred)
    handleIdentifier(deferred, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, deferred)
      handleNoType(deferred)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do)
    handleIdentifier(do, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, do)
      handleNoType(do)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'dynamic' as a name here., null, {lexeme: dynamic}], dynamic, dynamic)
    handleIdentifier(dynamic, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, dynamic)
      handleNoType(dynamic)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else)
    handleIdentifier(else, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, else)
      handleNoType(else)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
    handleIdentifier(enum, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, enum)
      handleNoType(enum)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'export' as a name here., null, {lexeme: export}], export, export)
    handleIdentifier(export, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, export)
      handleNoType(export)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
    handleIdentifier(extends, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, extends)
      handleNoType(extends)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'extension' as a name here., null, {lexeme: extension}], extension, extension)
    handleIdentifier(extension, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, extension)
      handleNoType(extension)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'external' as a name here., null, {lexeme: external}], external, external)
    handleIdentifier(external, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, external)
      handleNoType(external)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'factory' as a name here., null, {lexeme: factory}], factory, factory)
    handleIdentifier(factory, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, factory)
      handleNoType(factory)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false)
    handleIdentifier(false, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, false)
      handleNoType(false)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final)
    handleIdentifier(final, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, final)
      handleNoType(final)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
    handleIdentifier(finally, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, finally)
      handleNoType(finally)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for)
    handleIdentifier(for, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, for)
      handleNoType(for)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(Function, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, Function)
      handleNoType(Function)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'get' as a name here., null, {lexeme: get}], get, get)
    handleIdentifier(get, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, get)
      handleNoType(get)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(hide, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, hide)
      handleNoType(hide)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if)
    handleIdentifier(if, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, if)
      handleNoType(if)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'implements' as a name here., null, {lexeme: implements}], implements, implements)
    handleIdentifier(implements, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, implements)
      handleNoType(implements)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'import' as a name here., null, {lexeme: import}], import, import)
    handleIdentifier(import, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, import)
      handleNoType(import)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
    handleIdentifier(in, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, in)
      handleNoType(in)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(inout, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, inout)
      handleNoType(inout)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'interface' as a name here., null, {lexeme: interface}], interface, interface)
    handleIdentifier(interface, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, interface)
      handleNoType(interface)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is)
    handleIdentifier(is, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, is)
      handleNoType(is)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'late' as a name here., null, {lexeme: late}], late, late)
    handleIdentifier(late, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, late)
      handleNoType(late)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'library' as a name here., null, {lexeme: library}], library, library)
    handleIdentifier(library, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, library)
      handleNoType(library)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'mixin' as a name here., null, {lexeme: mixin}], mixin, mixin)
    handleIdentifier(mixin, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, mixin)
      handleNoType(mixin)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(native, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, native)
      handleNoType(native)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new)
    handleIdentifier(new, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, new)
      handleNoType(new)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null)
    handleIdentifier(null, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, null)
      handleNoType(null)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(of, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, of)
      handleNoType(of)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(on, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, on)
      handleNoType(on)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'operator' as a name here., null, {lexeme: operator}], operator, operator)
    handleIdentifier(operator, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, operator)
      handleNoType(operator)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(out, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, out)
      handleNoType(out)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'part' as a name here., null, {lexeme: part}], part, part)
    handleIdentifier(part, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, part)
      handleNoType(part)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(patch, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, patch)
      handleNoType(patch)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'required' as a name here., null, {lexeme: required}], required, required)
    handleIdentifier(required, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, required)
      handleNoType(required)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
    handleIdentifier(rethrow, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, rethrow)
      handleNoType(rethrow)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return)
    handleIdentifier(return, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, return)
      handleNoType(return)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'set' as a name here., null, {lexeme: set}], set, set)
    handleIdentifier(set, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, set)
      handleNoType(set)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(show, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, show)
      handleNoType(show)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(source, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, source)
      handleNoType(source)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'static' as a name here., null, {lexeme: static}], static, static)
    handleIdentifier(static, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, static)
      handleNoType(static)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super)
    handleIdentifier(super, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, super)
      handleNoType(super)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch)
    handleIdentifier(switch, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, switch)
      handleNoType(switch)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(sync, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, sync)
      handleNoType(sync)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this)
    handleIdentifier(this, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, this)
      handleNoType(this)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw)
    handleIdentifier(throw, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, throw)
      handleNoType(throw)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true)
    handleIdentifier(true, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, true)
      handleNoType(true)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try)
    handleIdentifier(try, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, try)
      handleNoType(try)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'typedef' as a name here., null, {lexeme: typedef}], typedef, typedef)
    handleIdentifier(typedef, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, typedef)
      handleNoType(typedef)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var)
    handleIdentifier(var, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, var)
      handleNoType(var)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void)
    handleIdentifier(void, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, void)
      handleNoType(void)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while)
    handleIdentifier(while, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, while)
      handleNoType(while)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
    handleIdentifier(with, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, with)
      handleNoType(with)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrNamedMixinApplicationPrelude(class)
    handleIdentifier(yield, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, yield)
      handleNoType(yield)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleClassOrMixinImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinBody(DeclarationKind.Class, {)
      endClassOrMixinBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration()
endCompilationUnit(69, )