parseUnit(import)
  skipErrorTokens(import)
  listener: beginCompilationUnit(import)
  syntheticPreviousToken(import)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(import)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, import, null, Instance of 'DirectiveContext')
      parseImport(import)
        listener: beginUncategorizedTopLevelDeclaration(import)
        listener: beginImport(import)
        ensureLiteralString(import)
          parseLiteralString(import)
            parseSingleLiteralString(import)
              listener: beginLiteralString("lib.dart")
              listener: endLiteralString(0, show)
        parseConditionalUriStar("lib.dart")
          listener: beginConditionalUris(show)
          listener: endConditionalUris(0)
        parseImportPrefixOpt("lib.dart")
          listener: handleImportPrefix(null, null)
        parseCombinatorStar("lib.dart")
          listener: beginCombinators(show)
          parseShow("lib.dart")
            listener: beginShow(show)
            parseIdentifierList(show)
              ensureIdentifier(show, combinator)
                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, combinator)
              listener: handleIdentifierList(1)
            listener: endShow(show)
          listener: endCombinators(1)
        listener: endImport(import, ;)
  listener: endTopLevelDeclaration(import)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(import)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, import, null, Instance of 'DirectiveContext')
      parseImport(import)
        listener: beginUncategorizedTopLevelDeclaration(import)
        listener: beginImport(import)
        ensureLiteralString(import)
          parseLiteralString(import)
            parseSingleLiteralString(import)
              listener: beginLiteralString("lib.dart")
              listener: endLiteralString(0, hide)
        parseConditionalUriStar("lib.dart")
          listener: beginConditionalUris(hide)
          listener: endConditionalUris(0)
        parseImportPrefixOpt("lib.dart")
          listener: handleImportPrefix(null, null)
        parseCombinatorStar("lib.dart")
          listener: beginCombinators(hide)
          parseHide("lib.dart")
            listener: beginHide(hide)
            parseIdentifierList(hide)
              ensureIdentifier(hide, combinator)
                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, combinator)
              listener: handleIdentifierList(1)
            listener: endHide(hide)
          listener: endCombinators(1)
        listener: endImport(import, ;)
  listener: endTopLevelDeclaration(import)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(import)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, import, null, Instance of 'DirectiveContext')
      parseImport(import)
        listener: beginUncategorizedTopLevelDeclaration(import)
        listener: beginImport(import)
        ensureLiteralString(import)
          parseLiteralString(import)
            parseSingleLiteralString(import)
              listener: beginLiteralString("lib.dart")
              listener: endLiteralString(0, as)
        parseConditionalUriStar("lib.dart")
          listener: beginConditionalUris(as)
          listener: endConditionalUris(0)
        parseImportPrefixOpt("lib.dart")
          ensureIdentifier(as, importPrefixDeclaration)
            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, importPrefixDeclaration)
          listener: handleImportPrefix(null, as)
        parseCombinatorStar(enum)
          listener: beginCombinators(show)
          parseShow(enum)
            listener: beginShow(show)
            parseIdentifierList(show)
              ensureIdentifier(show, combinator)
                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, combinator)
              listener: handleIdentifierList(1)
            listener: endShow(show)
          parseHide(enum)
            listener: beginHide(hide)
            parseIdentifierList(hide)
              ensureIdentifier(hide, combinator)
                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, combinator)
              listener: handleIdentifierList(1)
            listener: endHide(hide)
          listener: endCombinators(2)
        listener: endImport(import, ;)
  listener: endTopLevelDeclaration(import)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(import)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, import, null, Instance of 'DirectiveContext')
      parseImport(import)
        listener: beginUncategorizedTopLevelDeclaration(import)
        listener: beginImport(import)
        ensureLiteralString(import)
          parseLiteralString(import)
            parseSingleLiteralString(import)
              listener: beginLiteralString("lib.dart")
              listener: endLiteralString(0, show)
        parseConditionalUriStar("lib.dart")
          listener: beginConditionalUris(show)
          listener: endConditionalUris(0)
        parseImportPrefixOpt("lib.dart")
          listener: handleImportPrefix(null, null)
        parseCombinatorStar("lib.dart")
          listener: beginCombinators(show)
          parseShow("lib.dart")
            listener: beginShow(show)
            parseIdentifierList(show)
              ensureIdentifier(show, combinator)
                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, combinator)
              listener: handleIdentifierList(1)
            listener: endShow(show)
          parseHide(enum)
            listener: beginHide(hide)
            parseIdentifierList(hide)
              ensureIdentifier(hide, combinator)
                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, combinator)
              listener: handleIdentifierList(1)
            listener: endHide(hide)
          listener: endCombinators(2)
        listener: endImport(import, null)
        parseImportRecovery("lib.dart")
          parseConditionalUriStar("lib.dart")
          parseImportPrefixOpt("lib.dart")
          parseCombinatorStar("lib.dart")
            parseShow("lib.dart")
              parseIdentifierList(show)
                ensureIdentifier(show, combinator)
                  reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
            parseHide(enum)
              parseIdentifierList(hide)
                ensureIdentifier(hide, combinator)
                  reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
          skipUnexpectedTokenOpt(enum, [if, deferred, as, hide, show, ;])
          parseConditionalUriStar(enum)
            listener: beginConditionalUris(as)
            listener: endConditionalUris(0)
          parseImportPrefixOpt(enum)
            ensureIdentifier(as, importPrefixDeclaration)
              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, importPrefixDeclaration)
            listener: handleImportPrefix(null, as)
          reportRecoverableError(as, PrefixAfterCombinator)
            listener: handleRecoverableError(PrefixAfterCombinator, as, as)
          parseCombinatorStar(enum)
            listener: beginCombinators(;)
            listener: endCombinators(0)
          listener: handleRecoverImport(;)
  listener: endTopLevelDeclaration(import)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(import)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, import, null, Instance of 'DirectiveContext')
      parseImport(import)
        listener: beginUncategorizedTopLevelDeclaration(import)
        listener: beginImport(import)
        ensureLiteralString(import)
          parseLiteralString(import)
            parseSingleLiteralString(import)
              listener: beginLiteralString("lib.dart")
              listener: endLiteralString(0, show)
        parseConditionalUriStar("lib.dart")
          listener: beginConditionalUris(show)
          listener: endConditionalUris(0)
        parseImportPrefixOpt("lib.dart")
          listener: handleImportPrefix(null, null)
        parseCombinatorStar("lib.dart")
          listener: beginCombinators(show)
          parseShow("lib.dart")
            listener: beginShow(show)
            parseIdentifierList(show)
              ensureIdentifier(show, combinator)
                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, combinator)
              ensureIdentifier(,, combinator)
                listener: handleIdentifier(x, combinator)
              ensureIdentifier(,, combinator)
                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, combinator)
              listener: handleIdentifierList(3)
            listener: endShow(show)
          listener: endCombinators(1)
        listener: endImport(import, ;)
  listener: endTopLevelDeclaration(import)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(import)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, import, null, Instance of 'DirectiveContext')
      parseImport(import)
        listener: beginUncategorizedTopLevelDeclaration(import)
        listener: beginImport(import)
        ensureLiteralString(import)
          parseLiteralString(import)
            parseSingleLiteralString(import)
              listener: beginLiteralString("lib.dart")
              listener: endLiteralString(0, hide)
        parseConditionalUriStar("lib.dart")
          listener: beginConditionalUris(hide)
          listener: endConditionalUris(0)
        parseImportPrefixOpt("lib.dart")
          listener: handleImportPrefix(null, null)
        parseCombinatorStar("lib.dart")
          listener: beginCombinators(hide)
          parseHide("lib.dart")
            listener: beginHide(hide)
            parseIdentifierList(hide)
              ensureIdentifier(hide, combinator)
                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, combinator)
              ensureIdentifier(,, combinator)
                listener: handleIdentifier(x, combinator)
              ensureIdentifier(,, combinator)
                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, combinator)
              listener: handleIdentifierList(3)
            listener: endHide(hide)
          listener: endCombinators(1)
        listener: endImport(import, ;)
  listener: endTopLevelDeclaration(import)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(import)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, import, null, Instance of 'DirectiveContext')
      parseImport(import)
        listener: beginUncategorizedTopLevelDeclaration(import)
        listener: beginImport(import)
        ensureLiteralString(import)
          parseLiteralString(import)
            parseSingleLiteralString(import)
              listener: beginLiteralString("lib.dart")
              listener: endLiteralString(0, as)
        parseConditionalUriStar("lib.dart")
          listener: beginConditionalUris(as)
          listener: endConditionalUris(0)
        parseImportPrefixOpt("lib.dart")
          ensureIdentifier(as, importPrefixDeclaration)
            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, importPrefixDeclaration)
          listener: handleImportPrefix(null, as)
        parseCombinatorStar(enum)
          listener: beginCombinators(show)
          parseShow(enum)
            listener: beginShow(show)
            parseIdentifierList(show)
              ensureIdentifier(show, combinator)
                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, combinator)
              ensureIdentifier(,, combinator)
                listener: handleIdentifier(x, combinator)
              ensureIdentifier(,, combinator)
                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, combinator)
              listener: handleIdentifierList(3)
            listener: endShow(show)
          parseHide(enum)
            listener: beginHide(hide)
            parseIdentifierList(hide)
              ensureIdentifier(hide, combinator)
                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, combinator)
              ensureIdentifier(,, combinator)
                listener: handleIdentifier(x, combinator)
              ensureIdentifier(,, combinator)
                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, combinator)
              listener: handleIdentifierList(3)
            listener: endHide(hide)
          listener: endCombinators(2)
        listener: endImport(import, ;)
  listener: endTopLevelDeclaration(import)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(import)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(;, import, null, Instance of 'DirectiveContext')
      parseImport(import)
        listener: beginUncategorizedTopLevelDeclaration(import)
        listener: beginImport(import)
        ensureLiteralString(import)
          parseLiteralString(import)
            parseSingleLiteralString(import)
              listener: beginLiteralString("lib.dart")
              listener: endLiteralString(0, show)
        parseConditionalUriStar("lib.dart")
          listener: beginConditionalUris(show)
          listener: endConditionalUris(0)
        parseImportPrefixOpt("lib.dart")
          listener: handleImportPrefix(null, null)
        parseCombinatorStar("lib.dart")
          listener: beginCombinators(show)
          parseShow("lib.dart")
            listener: beginShow(show)
            parseIdentifierList(show)
              ensureIdentifier(show, combinator)
                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, combinator)
              ensureIdentifier(,, combinator)
                listener: handleIdentifier(x, combinator)
              ensureIdentifier(,, combinator)
                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, combinator)
              listener: handleIdentifierList(3)
            listener: endShow(show)
          parseHide(enum)
            listener: beginHide(hide)
            parseIdentifierList(hide)
              ensureIdentifier(hide, combinator)
                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, combinator)
              ensureIdentifier(,, combinator)
                listener: handleIdentifier(x, combinator)
              ensureIdentifier(,, combinator)
                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, combinator)
              listener: handleIdentifierList(3)
            listener: endHide(hide)
          listener: endCombinators(2)
        listener: endImport(import, null)
        parseImportRecovery("lib.dart")
          parseConditionalUriStar("lib.dart")
          parseImportPrefixOpt("lib.dart")
          parseCombinatorStar("lib.dart")
            parseShow("lib.dart")
              parseIdentifierList(show)
                ensureIdentifier(show, combinator)
                  reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
                ensureIdentifier(,, combinator)
                ensureIdentifier(,, combinator)
                  reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
            parseHide(enum)
              parseIdentifierList(hide)
                ensureIdentifier(hide, combinator)
                  reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
                ensureIdentifier(,, combinator)
                ensureIdentifier(,, combinator)
                  reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
          skipUnexpectedTokenOpt(enum, [if, deferred, as, hide, show, ;])
          parseConditionalUriStar(enum)
            listener: beginConditionalUris(as)
            listener: endConditionalUris(0)
          parseImportPrefixOpt(enum)
            ensureIdentifier(as, importPrefixDeclaration)
              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, importPrefixDeclaration)
            listener: handleImportPrefix(null, as)
          reportRecoverableError(as, PrefixAfterCombinator)
            listener: handleRecoverableError(PrefixAfterCombinator, as, as)
          parseCombinatorStar(enum)
            listener: beginCombinators(;)
            listener: endCombinators(0)
          listener: handleRecoverImport(;)
  listener: endTopLevelDeclaration(main)
  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
    parseMetadataStar(;)
      listener: beginMetadataStar(main)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(;)
      listener: beginTopLevelMember(main)
      isReservedKeyword(()
      parseTopLevelMethod(;, null, null, ;, Instance of 'NoType', null, main, false)
        listener: beginTopLevelMethod(;, null, null)
        listener: handleNoType(;)
        ensureIdentifierPotentiallyRecovered(;, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(main, topLevelFunctionDeclaration)
        parseMethodTypeVar(main)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(main, main, false, MemberKind.TopLevelMethod)
          parseFormalParameters(main, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(0, {, })
        listener: endTopLevelMethod(main, null, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(import)
  listener: endCompilationUnit(9, )