parseUnit(typedef)
  skipErrorTokens(typedef)
  listener: beginCompilationUnit(typedef)
  syntheticPreviousToken(typedef)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(abstract, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'abstract' 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: abstract}], abstract, abstract)
          listener: handleIdentifier(abstract, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(abstract, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(abstract, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'abstract' 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: abstract}], abstract, abstract)
          listener: handleIdentifier(abstract, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(as, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'as' 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: as}], as, as)
          listener: handleIdentifier(as, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(as, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(as, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'as' 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: as}], as, as)
          listener: handleIdentifier(as, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(assert, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(async, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(async, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(async, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(await, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(await, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(await, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(break, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(case, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(catch, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(class, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(const, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(continue, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(covariant, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'covariant' 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: covariant}], covariant, covariant)
          listener: handleIdentifier(covariant, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(covariant, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(covariant, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'covariant' 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: covariant}], covariant, covariant)
          listener: handleIdentifier(covariant, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(default, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(deferred, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'deferred' 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: deferred}], deferred, deferred)
          listener: handleIdentifier(deferred, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(deferred, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(deferred, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'deferred' 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: deferred}], deferred, deferred)
          listener: handleIdentifier(deferred, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(do, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(dynamic, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'dynamic' 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: dynamic}], dynamic, dynamic)
          listener: handleIdentifier(dynamic, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(dynamic, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(dynamic, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'dynamic' 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: dynamic}], dynamic, dynamic)
          listener: handleIdentifier(dynamic, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(else, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(enum, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(export, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'export' 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: export}], export, export)
          listener: handleIdentifier(export, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(export, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(export, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'export' 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: export}], export, export)
          listener: handleIdentifier(export, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(extends, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(extension, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extension' 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: extension}], extension, extension)
          listener: handleIdentifier(extension, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(extension, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(extension, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extension' 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: extension}], extension, extension)
          listener: handleIdentifier(extension, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(external, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'external' 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: external}], external, external)
          listener: handleIdentifier(external, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(external, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(external, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'external' 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: external}], external, external)
          listener: handleIdentifier(external, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(factory, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'factory' 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: factory}], factory, factory)
          listener: handleIdentifier(factory, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(factory, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(factory, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'factory' 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: factory}], factory, factory)
          listener: handleIdentifier(factory, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(false, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(final, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(finally, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(for, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(Function, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'Function' 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: Function}], Function, Function)
          listener: handleIdentifier(Function, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(Function, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(Function, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'Function' 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: Function}], Function, Function)
          listener: handleIdentifier(Function, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(get, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'get' 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: get}], get, get)
          listener: handleIdentifier(get, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(get, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(get, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'get' 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: get}], get, get)
          listener: handleIdentifier(get, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(hide, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(hide, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(hide, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(if, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(implements, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'implements' 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: implements}], implements, implements)
          listener: handleIdentifier(implements, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(implements, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(implements, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'implements' 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: implements}], implements, implements)
          listener: handleIdentifier(implements, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(import, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'import' 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: import}], import, import)
          listener: handleIdentifier(import, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(import, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(import, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'import' 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: import}], import, import)
          listener: handleIdentifier(import, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(in, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(inout, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(inout, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(inout, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(interface, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'interface' 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: interface}], interface, interface)
          listener: handleIdentifier(interface, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(interface, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(interface, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'interface' 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: interface}], interface, interface)
          listener: handleIdentifier(interface, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(is, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(late, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'late' 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: late}], late, late)
          listener: handleIdentifier(late, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(late, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(late, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'late' 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: late}], late, late)
          listener: handleIdentifier(late, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(library, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'library' 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: library}], library, library)
          listener: handleIdentifier(library, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(library, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(library, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'library' 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: library}], library, library)
          listener: handleIdentifier(library, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(mixin, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'mixin' 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: mixin}], mixin, mixin)
          listener: handleIdentifier(mixin, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(mixin, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(mixin, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'mixin' 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: mixin}], mixin, mixin)
          listener: handleIdentifier(mixin, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(native, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(native, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(native, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(new, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(null, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(of, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(of, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(of, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(on, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(on, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(on, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(operator, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'operator' 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: operator}], operator, operator)
          listener: handleIdentifier(operator, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(operator, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(operator, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'operator' 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: operator}], operator, operator)
          listener: handleIdentifier(operator, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(out, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(out, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(out, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(part, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'part' 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: part}], part, part)
          listener: handleIdentifier(part, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(part, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(part, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'part' 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: part}], part, part)
          listener: handleIdentifier(part, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(patch, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(patch, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(patch, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(required, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'required' 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: required}], required, required)
          listener: handleIdentifier(required, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(required, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(required, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'required' 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: required}], required, required)
          listener: handleIdentifier(required, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(rethrow, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(return, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(set, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'set' 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: set}], set, set)
          listener: handleIdentifier(set, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(set, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(set, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'set' 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: set}], set, set)
          listener: handleIdentifier(set, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(show, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(show, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(show, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(source, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(source, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(source, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(static, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'static' 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: static}], static, static)
          listener: handleIdentifier(static, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(static, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(static, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'static' 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: static}], static, static)
          listener: handleIdentifier(static, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(super, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(switch, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(sync, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(sync, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(sync, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(this, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(throw, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(true, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(try, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          reportRecoverableErrorWithToken(typedef, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'typedef' 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: typedef}], typedef, typedef)
          listener: handleIdentifier(typedef, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(typedef, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          reportRecoverableErrorWithToken(typedef, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'typedef' 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: typedef}], typedef, typedef)
          listener: handleIdentifier(typedef, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(var, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(void, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, false)
          insertSyntheticIdentifier(void, typedefDeclaration, message: Message[ExpectedIdentifier, Expected an identifier, but got '='., Try inserting an identifier before '='., {lexeme: =}], messageOnToken: null)
            reportRecoverableError(=, Message[ExpectedIdentifier, Expected an identifier, but got '='., Try inserting an identifier before '='., {lexeme: =}])
              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '='., Try inserting an identifier before '='., {lexeme: =}], =, =)
            rewriter()
          listener: handleIdentifier(, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        parseFormalParametersRequiredOpt(, MemberKind.FunctionTypeAlias)
          missingParameterMessage(MemberKind.FunctionTypeAlias)
          reportRecoverableError(=, MissingTypedefParameters)
            listener: handleRecoverableError(MissingTypedefParameters, =, =)
          rewriter()
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
          reportRecoverableError((, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
            listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], =, =)
          rewriter()
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(=)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(=)
      listener: endMetadataStar(0)
    listener: beginTopLevelMember(=)
    parseInvalidTopLevelDeclaration(;)
      reportRecoverableErrorWithToken(=, Instance of 'Template<(Token) => Message>')
        listener: handleRecoverableError(Message[ExpectedDeclaration, Expected a declaration, but got '='., null, {lexeme: =}], =, =)
      listener: handleInvalidTopLevelDeclaration(=)
  listener: endTopLevelDeclaration(void)
  parseTopLevelDeclarationImpl(=, Instance of 'DirectiveContext')
    parseMetadataStar(=)
      listener: beginMetadataStar(void)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(=)
      listener: beginTopLevelMember(void)
      parseTopLevelMethod(=, null, =, Instance of 'VoidType', null, Function, false)
        listener: beginTopLevelMethod(=, null)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(Function, topLevelFunctionDeclaration)
        parseMethodTypeVar(Function)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(Function, Function, false, MemberKind.TopLevelMethod)
          parseFormalParameters(Function, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          reportRecoverableError(;, ExpectedBody)
            listener: handleRecoverableError(ExpectedBody, ;, ;)
          listener: handleEmptyFunctionBody(;)
        listener: endTopLevelMethod(void, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(while, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(with, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          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, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        listener: handleVoidKeyword(void)
        ensureIdentifierPotentiallyRecovered(void, typedefDeclaration, true)
          listener: handleIdentifier(yield, typedefDeclaration)
        listener: handleNoTypeVariables(()
        parseFormalParametersRequiredOpt(yield, MemberKind.FunctionTypeAlias)
          parseFormalParametersRest((, MemberKind.FunctionTypeAlias)
            listener: beginFormalParameters((, MemberKind.FunctionTypeAlias)
            listener: endFormalParameters(0, (, ), MemberKind.FunctionTypeAlias)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, null, ;)
  listener: endTopLevelDeclaration(typedef)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(typedef)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, typedef, Instance of 'DirectiveContext')
      parseTopLevelKeywordModifiers(;, typedef)
      parseTypedef(typedef)
        listener: beginUncategorizedTopLevelDeclaration(typedef)
        listener: beginFunctionTypeAlias(typedef)
        ensureIdentifierPotentiallyRecovered(typedef, typedefDeclaration, true)
          listener: handleIdentifier(yield, typedefDeclaration)
        listener: handleNoTypeVariables(=)
        listener: beginFunctionType(void)
        listener: handleNoTypeVariables(()
        listener: handleVoidKeyword(void)
        parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
          parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
            listener: beginFormalParameters((, MemberKind.GeneralizedFunctionType)
            listener: endFormalParameters(0, (, ), MemberKind.GeneralizedFunctionType)
        listener: endFunctionType(Function, null)
        ensureSemicolon())
        listener: endFunctionTypeAlias(typedef, =, ;)
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(typedef)
  listener: endCompilationUnit(140, )