parseUnit(class)
  skipErrorTokens(class)
  listener: beginCompilationUnit(class)
  syntheticPreviousToken(class)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(abstract, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'abstract' as a name here., null, {lexeme: abstract}], abstract, abstract)
          listener: handleIdentifier(abstract, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, abstract)
        parseClass(abstract, class, class, abstract)
          parseClassHeaderOpt(abstract, class, class)
            parseClassExtendsOpt(abstract)
              listener: handleNoType(abstract)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(abstract)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(abstract)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(abstract, DeclarationKind.Class, abstract)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(as, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'as' as a name here., null, {lexeme: as}], as, as)
          listener: handleIdentifier(as, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, as)
        parseClass(as, class, class, as)
          parseClassHeaderOpt(as, class, class)
            parseClassExtendsOpt(as)
              listener: handleNoType(as)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(as)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(as)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(as, DeclarationKind.Class, as)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(assert, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert)
          listener: handleIdentifier(assert, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, assert)
        parseClass(assert, class, class, assert)
          parseClassHeaderOpt(assert, class, class)
            parseClassExtendsOpt(assert)
              listener: handleNoType(assert)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(assert)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(assert)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(assert, DeclarationKind.Class, assert)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(async, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, async)
        parseClass(async, class, class, async)
          parseClassHeaderOpt(async, class, class)
            parseClassExtendsOpt(async)
              listener: handleNoType(async)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(async)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(async)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(async, DeclarationKind.Class, async)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(await, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, await)
        parseClass(await, class, class, await)
          parseClassHeaderOpt(await, class, class)
            parseClassExtendsOpt(await)
              listener: handleNoType(await)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(await)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(await)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(await, DeclarationKind.Class, await)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break)
          listener: handleIdentifier(break, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, break)
        parseClass(break, class, class, break)
          parseClassHeaderOpt(break, class, class)
            parseClassExtendsOpt(break)
              listener: handleNoType(break)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(break)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(break)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(break, DeclarationKind.Class, break)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
          listener: handleIdentifier(case, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, case)
        parseClass(case, class, class, case)
          parseClassHeaderOpt(case, class, class)
            parseClassExtendsOpt(case)
              listener: handleNoType(case)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(case)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(case)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(case, DeclarationKind.Class, case)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
          listener: handleIdentifier(catch, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, catch)
        parseClass(catch, class, class, catch)
          parseClassHeaderOpt(catch, class, class)
            parseClassExtendsOpt(catch)
              listener: handleNoType(catch)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(catch)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(catch)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(catch, DeclarationKind.Class, catch)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
          listener: handleIdentifier(class, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, class)
        parseClass(class, class, class, class)
          parseClassHeaderOpt(class, class, class)
            parseClassExtendsOpt(class)
              listener: handleNoType(class)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(class)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(class)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(class, DeclarationKind.Class, class)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(const, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const)
          listener: handleIdentifier(const, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, const)
        parseClass(const, class, class, const)
          parseClassHeaderOpt(const, class, class)
            parseClassExtendsOpt(const)
              listener: handleNoType(const)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(const)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(const)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(const, DeclarationKind.Class, const)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue)
          listener: handleIdentifier(continue, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, continue)
        parseClass(continue, class, class, continue)
          parseClassHeaderOpt(continue, class, class)
            parseClassExtendsOpt(continue)
              listener: handleNoType(continue)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(continue)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(continue)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(continue, DeclarationKind.Class, continue)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(covariant, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'covariant' as a name here., null, {lexeme: covariant}], covariant, covariant)
          listener: handleIdentifier(covariant, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, covariant)
        parseClass(covariant, class, class, covariant)
          parseClassHeaderOpt(covariant, class, class)
            parseClassExtendsOpt(covariant)
              listener: handleNoType(covariant)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(covariant)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(covariant)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(covariant, DeclarationKind.Class, covariant)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
          listener: handleIdentifier(default, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, default)
        parseClass(default, class, class, default)
          parseClassHeaderOpt(default, class, class)
            parseClassExtendsOpt(default)
              listener: handleNoType(default)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(default)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(default)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(default, DeclarationKind.Class, default)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(deferred, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'deferred' as a name here., null, {lexeme: deferred}], deferred, deferred)
          listener: handleIdentifier(deferred, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, deferred)
        parseClass(deferred, class, class, deferred)
          parseClassHeaderOpt(deferred, class, class)
            parseClassExtendsOpt(deferred)
              listener: handleNoType(deferred)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(deferred)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(deferred)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(deferred, DeclarationKind.Class, deferred)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do)
          listener: handleIdentifier(do, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, do)
        parseClass(do, class, class, do)
          parseClassHeaderOpt(do, class, class)
            parseClassExtendsOpt(do)
              listener: handleNoType(do)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(do)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(do)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(do, DeclarationKind.Class, do)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(dynamic, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'dynamic' as a name here., null, {lexeme: dynamic}], dynamic, dynamic)
          listener: handleIdentifier(dynamic, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, dynamic)
        parseClass(dynamic, class, class, dynamic)
          parseClassHeaderOpt(dynamic, class, class)
            parseClassExtendsOpt(dynamic)
              listener: handleNoType(dynamic)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(dynamic)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(dynamic)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(dynamic, DeclarationKind.Class, dynamic)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else)
          listener: handleIdentifier(else, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, else)
        parseClass(else, class, class, else)
          parseClassHeaderOpt(else, class, class)
            parseClassExtendsOpt(else)
              listener: handleNoType(else)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(else)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(else)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(else, DeclarationKind.Class, else)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
          listener: handleIdentifier(enum, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, enum)
        parseClass(enum, class, class, enum)
          parseClassHeaderOpt(enum, class, class)
            parseClassExtendsOpt(enum)
              listener: handleNoType(enum)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(enum)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(enum)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(enum, DeclarationKind.Class, enum)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(export, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'export' as a name here., null, {lexeme: export}], export, export)
          listener: handleIdentifier(export, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, export)
        parseClass(export, class, class, export)
          parseClassHeaderOpt(export, class, class)
            parseClassExtendsOpt(export)
              listener: handleNoType(export)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(export)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(export)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(export, DeclarationKind.Class, export)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
          listener: handleIdentifier(extends, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, extends)
        parseClass(extends, class, class, extends)
          parseClassHeaderOpt(extends, class, class)
            parseClassExtendsOpt(extends)
              listener: handleNoType(extends)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(extends)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(extends)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(extends, DeclarationKind.Class, extends)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(extension, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'extension' as a name here., null, {lexeme: extension}], extension, extension)
          listener: handleIdentifier(extension, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, extension)
        parseClass(extension, class, class, extension)
          parseClassHeaderOpt(extension, class, class)
            parseClassExtendsOpt(extension)
              listener: handleNoType(extension)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(extension)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(extension)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(extension, DeclarationKind.Class, extension)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(external, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'external' as a name here., null, {lexeme: external}], external, external)
          listener: handleIdentifier(external, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, external)
        parseClass(external, class, class, external)
          parseClassHeaderOpt(external, class, class)
            parseClassExtendsOpt(external)
              listener: handleNoType(external)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(external)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(external)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(external, DeclarationKind.Class, external)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(factory, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'factory' as a name here., null, {lexeme: factory}], factory, factory)
          listener: handleIdentifier(factory, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, factory)
        parseClass(factory, class, class, factory)
          parseClassHeaderOpt(factory, class, class)
            parseClassExtendsOpt(factory)
              listener: handleNoType(factory)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(factory)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(factory)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(factory, DeclarationKind.Class, factory)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(false, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false)
          listener: handleIdentifier(false, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, false)
        parseClass(false, class, class, false)
          parseClassHeaderOpt(false, class, class)
            parseClassExtendsOpt(false)
              listener: handleNoType(false)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(false)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(false)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(false, DeclarationKind.Class, false)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final)
          listener: handleIdentifier(final, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, final)
        parseClass(final, class, class, final)
          parseClassHeaderOpt(final, class, class)
            parseClassExtendsOpt(final)
              listener: handleNoType(final)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(final)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(final)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(final, DeclarationKind.Class, final)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
          listener: handleIdentifier(finally, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, finally)
        parseClass(finally, class, class, finally)
          parseClassHeaderOpt(finally, class, class)
            parseClassExtendsOpt(finally)
              listener: handleNoType(finally)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(finally)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(finally)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(finally, DeclarationKind.Class, finally)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for)
          listener: handleIdentifier(for, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, for)
        parseClass(for, class, class, for)
          parseClassHeaderOpt(for, class, class)
            parseClassExtendsOpt(for)
              listener: handleNoType(for)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(for)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(for)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(for, DeclarationKind.Class, for)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Function, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, Function)
        parseClass(Function, class, class, Function)
          parseClassHeaderOpt(Function, class, class)
            parseClassExtendsOpt(Function)
              listener: handleNoType(Function)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(Function)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(Function)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Function, DeclarationKind.Class, Function)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(get, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'get' as a name here., null, {lexeme: get}], get, get)
          listener: handleIdentifier(get, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, get)
        parseClass(get, class, class, get)
          parseClassHeaderOpt(get, class, class)
            parseClassExtendsOpt(get)
              listener: handleNoType(get)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(get)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(get)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(get, DeclarationKind.Class, get)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(hide, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, hide)
        parseClass(hide, class, class, hide)
          parseClassHeaderOpt(hide, class, class)
            parseClassExtendsOpt(hide)
              listener: handleNoType(hide)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(hide)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(hide)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(hide, DeclarationKind.Class, hide)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if)
          listener: handleIdentifier(if, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, if)
        parseClass(if, class, class, if)
          parseClassHeaderOpt(if, class, class)
            parseClassExtendsOpt(if)
              listener: handleNoType(if)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(if)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(if)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(if, DeclarationKind.Class, if)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(implements, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'implements' as a name here., null, {lexeme: implements}], implements, implements)
          listener: handleIdentifier(implements, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, implements)
        parseClass(implements, class, class, implements)
          parseClassHeaderOpt(implements, class, class)
            parseClassExtendsOpt(implements)
              listener: handleNoType(implements)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(implements)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(implements)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(implements, DeclarationKind.Class, implements)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(import, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'import' as a name here., null, {lexeme: import}], import, import)
          listener: handleIdentifier(import, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, import)
        parseClass(import, class, class, import)
          parseClassHeaderOpt(import, class, class)
            parseClassExtendsOpt(import)
              listener: handleNoType(import)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(import)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(import)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(import, DeclarationKind.Class, import)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
          listener: handleIdentifier(in, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, in)
        parseClass(in, class, class, in)
          parseClassHeaderOpt(in, class, class)
            parseClassExtendsOpt(in)
              listener: handleNoType(in)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(in)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(in)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(in, DeclarationKind.Class, in)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(inout, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, inout)
        parseClass(inout, class, class, inout)
          parseClassHeaderOpt(inout, class, class)
            parseClassExtendsOpt(inout)
              listener: handleNoType(inout)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(inout)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(inout)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(inout, DeclarationKind.Class, inout)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(interface, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'interface' as a name here., null, {lexeme: interface}], interface, interface)
          listener: handleIdentifier(interface, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, interface)
        parseClass(interface, class, class, interface)
          parseClassHeaderOpt(interface, class, class)
            parseClassExtendsOpt(interface)
              listener: handleNoType(interface)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(interface)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(interface)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(interface, DeclarationKind.Class, interface)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is)
          listener: handleIdentifier(is, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, is)
        parseClass(is, class, class, is)
          parseClassHeaderOpt(is, class, class)
            parseClassExtendsOpt(is)
              listener: handleNoType(is)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(is)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(is)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(is, DeclarationKind.Class, is)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(late, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'late' as a name here., null, {lexeme: late}], late, late)
          listener: handleIdentifier(late, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, late)
        parseClass(late, class, class, late)
          parseClassHeaderOpt(late, class, class)
            parseClassExtendsOpt(late)
              listener: handleNoType(late)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(late)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(late)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(late, DeclarationKind.Class, late)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(library, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'library' as a name here., null, {lexeme: library}], library, library)
          listener: handleIdentifier(library, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, library)
        parseClass(library, class, class, library)
          parseClassHeaderOpt(library, class, class)
            parseClassExtendsOpt(library)
              listener: handleNoType(library)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(library)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(library)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(library, DeclarationKind.Class, library)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(mixin, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'mixin' as a name here., null, {lexeme: mixin}], mixin, mixin)
          listener: handleIdentifier(mixin, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, mixin)
        parseClass(mixin, class, class, mixin)
          parseClassHeaderOpt(mixin, class, class)
            parseClassExtendsOpt(mixin)
              listener: handleNoType(mixin)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(mixin)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(mixin)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(mixin, DeclarationKind.Class, mixin)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(native, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, native)
        parseClass(native, class, class, native)
          parseClassHeaderOpt(native, class, class)
            parseClassExtendsOpt(native)
              listener: handleNoType(native)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(native)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(native)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(native, DeclarationKind.Class, native)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(new, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new)
          listener: handleIdentifier(new, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, new)
        parseClass(new, class, class, new)
          parseClassHeaderOpt(new, class, class)
            parseClassExtendsOpt(new)
              listener: handleNoType(new)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(new)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(new)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(new, DeclarationKind.Class, new)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(null, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null)
          listener: handleIdentifier(null, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, null)
        parseClass(null, class, class, null)
          parseClassHeaderOpt(null, class, class)
            parseClassExtendsOpt(null)
              listener: handleNoType(null)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(null)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(null)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(null, DeclarationKind.Class, null)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(of, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, of)
        parseClass(of, class, class, of)
          parseClassHeaderOpt(of, class, class)
            parseClassExtendsOpt(of)
              listener: handleNoType(of)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(of)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(of)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(of, DeclarationKind.Class, of)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(on, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, on)
        parseClass(on, class, class, on)
          parseClassHeaderOpt(on, class, class)
            parseClassExtendsOpt(on)
              listener: handleNoType(on)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(on)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(on)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(on, DeclarationKind.Class, on)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(operator, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'operator' as a name here., null, {lexeme: operator}], operator, operator)
          listener: handleIdentifier(operator, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, operator)
        parseClass(operator, class, class, operator)
          parseClassHeaderOpt(operator, class, class)
            parseClassExtendsOpt(operator)
              listener: handleNoType(operator)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(operator)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(operator)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(operator, DeclarationKind.Class, operator)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(out, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, out)
        parseClass(out, class, class, out)
          parseClassHeaderOpt(out, class, class)
            parseClassExtendsOpt(out)
              listener: handleNoType(out)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(out)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(out)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(out, DeclarationKind.Class, out)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(part, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'part' as a name here., null, {lexeme: part}], part, part)
          listener: handleIdentifier(part, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, part)
        parseClass(part, class, class, part)
          parseClassHeaderOpt(part, class, class)
            parseClassExtendsOpt(part)
              listener: handleNoType(part)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(part)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(part)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(part, DeclarationKind.Class, part)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(patch, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, patch)
        parseClass(patch, class, class, patch)
          parseClassHeaderOpt(patch, class, class)
            parseClassExtendsOpt(patch)
              listener: handleNoType(patch)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(patch)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(patch)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(patch, DeclarationKind.Class, patch)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(required, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'required' as a name here., null, {lexeme: required}], required, required)
          listener: handleIdentifier(required, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, required)
        parseClass(required, class, class, required)
          parseClassHeaderOpt(required, class, class)
            parseClassExtendsOpt(required)
              listener: handleNoType(required)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(required)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(required)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(required, DeclarationKind.Class, required)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
          listener: handleIdentifier(rethrow, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, rethrow)
        parseClass(rethrow, class, class, rethrow)
          parseClassHeaderOpt(rethrow, class, class)
            parseClassExtendsOpt(rethrow)
              listener: handleNoType(rethrow)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(rethrow)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(rethrow)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(rethrow, DeclarationKind.Class, rethrow)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return)
          listener: handleIdentifier(return, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, return)
        parseClass(return, class, class, return)
          parseClassHeaderOpt(return, class, class)
            parseClassExtendsOpt(return)
              listener: handleNoType(return)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(return)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(return)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(return, DeclarationKind.Class, return)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(set, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'set' as a name here., null, {lexeme: set}], set, set)
          listener: handleIdentifier(set, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, set)
        parseClass(set, class, class, set)
          parseClassHeaderOpt(set, class, class)
            parseClassExtendsOpt(set)
              listener: handleNoType(set)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(set)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(set)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(set, DeclarationKind.Class, set)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(show, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, show)
        parseClass(show, class, class, show)
          parseClassHeaderOpt(show, class, class)
            parseClassExtendsOpt(show)
              listener: handleNoType(show)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(show)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(show)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(show, DeclarationKind.Class, show)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(source, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, source)
        parseClass(source, class, class, source)
          parseClassHeaderOpt(source, class, class)
            parseClassExtendsOpt(source)
              listener: handleNoType(source)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(source)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(source)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(source, DeclarationKind.Class, source)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(static, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'static' as a name here., null, {lexeme: static}], static, static)
          listener: handleIdentifier(static, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, static)
        parseClass(static, class, class, static)
          parseClassHeaderOpt(static, class, class)
            parseClassExtendsOpt(static)
              listener: handleNoType(static)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(static)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(static)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(static, DeclarationKind.Class, static)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(super, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super)
          listener: handleIdentifier(super, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, super)
        parseClass(super, class, class, super)
          parseClassHeaderOpt(super, class, class)
            parseClassExtendsOpt(super)
              listener: handleNoType(super)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(super)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(super)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(super, DeclarationKind.Class, super)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch)
          listener: handleIdentifier(switch, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, switch)
        parseClass(switch, class, class, switch)
          parseClassHeaderOpt(switch, class, class)
            parseClassExtendsOpt(switch)
              listener: handleNoType(switch)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(switch)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(switch)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(switch, DeclarationKind.Class, switch)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(sync, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, sync)
        parseClass(sync, class, class, sync)
          parseClassHeaderOpt(sync, class, class)
            parseClassExtendsOpt(sync)
              listener: handleNoType(sync)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(sync)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(sync)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(sync, DeclarationKind.Class, sync)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(this, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this)
          listener: handleIdentifier(this, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, this)
        parseClass(this, class, class, this)
          parseClassHeaderOpt(this, class, class)
            parseClassExtendsOpt(this)
              listener: handleNoType(this)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(this)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(this)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(this, DeclarationKind.Class, this)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(throw, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: throw}], throw, throw)
          listener: handleIdentifier(throw, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, throw)
        parseClass(throw, class, class, throw)
          parseClassHeaderOpt(throw, class, class)
            parseClassExtendsOpt(throw)
              listener: handleNoType(throw)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(throw)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(throw)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(throw, DeclarationKind.Class, throw)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(true, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: true}], true, true)
          listener: handleIdentifier(true, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, true)
        parseClass(true, class, class, true)
          parseClassHeaderOpt(true, class, class)
            parseClassExtendsOpt(true)
              listener: handleNoType(true)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(true)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(true)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(true, DeclarationKind.Class, true)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: try}], try, try)
          listener: handleIdentifier(try, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, try)
        parseClass(try, class, class, try)
          parseClassHeaderOpt(try, class, class)
            parseClassExtendsOpt(try)
              listener: handleNoType(try)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(try)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(try)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(try, DeclarationKind.Class, try)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(typedef, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[BuiltInIdentifierInDeclaration, Can't use 'typedef' as a name here., null, {lexeme: typedef}], typedef, typedef)
          listener: handleIdentifier(typedef, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, typedef)
        parseClass(typedef, class, class, typedef)
          parseClassHeaderOpt(typedef, class, class)
            parseClassExtendsOpt(typedef)
              listener: handleNoType(typedef)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(typedef)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(typedef)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(typedef, DeclarationKind.Class, typedef)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: var}], var, var)
          listener: handleIdentifier(var, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, var)
        parseClass(var, class, class, var)
          parseClassHeaderOpt(var, class, class)
            parseClassExtendsOpt(var)
              listener: handleNoType(var)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(var)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(var)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(var, DeclarationKind.Class, var)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: void}], void, void)
          listener: handleIdentifier(void, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, void)
        parseClass(void, class, class, void)
          parseClassHeaderOpt(void, class, class)
            parseClassExtendsOpt(void)
              listener: handleNoType(void)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(void)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(void)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(void, DeclarationKind.Class, void)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: while}], while, while)
          listener: handleIdentifier(while, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, while)
        parseClass(while, class, class, while)
          parseClassHeaderOpt(while, class, class)
            parseClassExtendsOpt(while)
              listener: handleNoType(while)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(while)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(while)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(while, DeclarationKind.Class, while)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
          listener: handleIdentifier(with, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, with)
        parseClass(with, class, class, with)
          parseClassHeaderOpt(with, class, class)
            parseClassExtendsOpt(with)
              listener: handleNoType(with)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(with)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(with)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(with, DeclarationKind.Class, with)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(class)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(}, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(yield, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, yield)
        parseClass(yield, class, class, yield)
          parseClassHeaderOpt(yield, class, class)
            parseClassExtendsOpt(yield)
              listener: handleNoType(yield)
              listener: handleClassExtends(null, 1)
            parseWithClauseOpt(yield)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(yield)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(yield, DeclarationKind.Class, yield)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(69, )