pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_1.dart.intertwined.expect

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: beginNamedMixinApplication(class, null, abstract)
        parseNamedMixinApplication(abstract, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, as)
        parseNamedMixinApplication(as, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, assert)
        parseNamedMixinApplication(assert, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, async)
        parseNamedMixinApplication(async, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, await)
        parseNamedMixinApplication(await, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, break)
        parseNamedMixinApplication(break, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, case)
        parseNamedMixinApplication(case, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, catch)
        parseNamedMixinApplication(catch, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, class)
        parseNamedMixinApplication(class, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, const)
        parseNamedMixinApplication(const, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, continue)
        parseNamedMixinApplication(continue, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, covariant)
        parseNamedMixinApplication(covariant, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, default)
        parseNamedMixinApplication(default, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, deferred)
        parseNamedMixinApplication(deferred, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, do)
        parseNamedMixinApplication(do, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, dynamic)
        parseNamedMixinApplication(dynamic, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, else)
        parseNamedMixinApplication(else, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, enum)
        parseNamedMixinApplication(enum, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, export)
        parseNamedMixinApplication(export, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, extends)
        parseNamedMixinApplication(extends, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, extension)
        parseNamedMixinApplication(extension, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, external)
        parseNamedMixinApplication(external, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, factory)
        parseNamedMixinApplication(factory, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, false)
        parseNamedMixinApplication(false, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, final)
        parseNamedMixinApplication(final, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, finally)
        parseNamedMixinApplication(finally, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, for)
        parseNamedMixinApplication(for, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, Function)
        parseNamedMixinApplication(Function, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, get)
        parseNamedMixinApplication(get, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, hide)
        parseNamedMixinApplication(hide, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, if)
        parseNamedMixinApplication(if, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, implements)
        parseNamedMixinApplication(implements, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, import)
        parseNamedMixinApplication(import, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, in)
        parseNamedMixinApplication(in, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, inout)
        parseNamedMixinApplication(inout, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, interface)
        parseNamedMixinApplication(interface, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, is)
        parseNamedMixinApplication(is, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, late)
        parseNamedMixinApplication(late, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, library)
        parseNamedMixinApplication(library, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, mixin)
        parseNamedMixinApplication(mixin, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, native)
        parseNamedMixinApplication(native, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, new)
        parseNamedMixinApplication(new, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, null)
        parseNamedMixinApplication(null, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, of)
        parseNamedMixinApplication(of, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, on)
        parseNamedMixinApplication(on, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, operator)
        parseNamedMixinApplication(operator, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, out)
        parseNamedMixinApplication(out, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, part)
        parseNamedMixinApplication(part, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, patch)
        parseNamedMixinApplication(patch, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, required)
        parseNamedMixinApplication(required, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, rethrow)
        parseNamedMixinApplication(rethrow, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, return)
        parseNamedMixinApplication(return, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, set)
        parseNamedMixinApplication(set, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, show)
        parseNamedMixinApplication(show, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, source)
        parseNamedMixinApplication(source, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, static)
        parseNamedMixinApplication(static, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, super)
        parseNamedMixinApplication(super, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, switch)
        parseNamedMixinApplication(switch, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, sync)
        parseNamedMixinApplication(sync, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, this)
        parseNamedMixinApplication(this, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, throw)
        parseNamedMixinApplication(throw, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, true)
        parseNamedMixinApplication(true, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, try)
        parseNamedMixinApplication(try, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, typedef)
        parseNamedMixinApplication(typedef, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, var)
        parseNamedMixinApplication(var, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, void)
        parseNamedMixinApplication(void, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, while)
        parseNamedMixinApplication(while, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, with)
        parseNamedMixinApplication(with, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  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: beginNamedMixinApplication(class, null, yield)
        parseNamedMixinApplication(yield, class, class)
          listener: handleIdentifier(A, typeReference)
          listener: handleNoTypeArguments(with)
          listener: handleType(A, null)
          parseMixinApplicationRest(A)
            parseTypeList(with)
              listener: beginTypeList(B)
              listener: handleIdentifier(B, typeReference)
              listener: handleNoTypeArguments(;)
              listener: handleType(B, null)
              listener: endTypeList(1)
            listener: handleNamedMixinApplicationWithClause(with)
          ensureSemicolon(B)
          listener: endNamedMixinApplication(class, class, =, null, ;)
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(69, )