parseUnit(enum)
  skipErrorTokens(enum)
  listener: beginCompilationUnit(enum)
  syntheticPreviousToken(enum)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(w)
          recoverySmallLookAheadSkipTokens(E, [{, with, implements])
            reportRecoverableError(w, Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w)
          parseEnumWithClauseOpt(w)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(w)
            listener: handleImplements(null, 0)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(w)
          recoverySmallLookAheadSkipTokens(E, [{, with, implements])
            reportRecoverableError(w, Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w)
          parseEnumWithClauseOpt(w)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(w)
            listener: handleIdentifier(Foo, typeReference)
            listener: handleNoTypeArguments({)
            listener: handleType(Foo, null)
            listener: handleImplements(implements, 1)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(implements)
          parseEnumWithClauseOpt(E)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(E)
            listener: handleIdentifier(Foo, typeReference)
            listener: handleNoTypeArguments(with)
            listener: handleType(Foo, null)
            listener: handleImplements(implements, 1)
          recoveryEnumWith(Foo, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
            reportRecoverableError(with, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
              listener: handleRecoverableError(Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}], with, with)
            parseEnumWithClauseOpt(Foo)
              parseTypeList(with)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(implements)
          parseEnumWithClauseOpt(E)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(E)
            listener: handleIdentifier(Foo, typeReference)
            listener: handleNoTypeArguments(implements)
            listener: handleType(Foo, null)
            listener: handleImplements(implements, 1)
          recoveryEnumWith(Foo, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
          recoveryEnumImplements(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
            reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements)
            parseClassOrMixinOrEnumImplementsOpt(Foo)
          recoveryEnumWith(Bar, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
          recoveryEnumImplements(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
            reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements)
            parseClassOrMixinOrEnumImplementsOpt(Bar)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(w)
          recoverySmallLookAheadSkipTokens(E, [{, with, implements])
            reportRecoverableErrorWithEnd(w, Foo, UnexpectedTokens)
              listener: handleRecoverableError(UnexpectedTokens, w, Foo)
          parseEnumWithClauseOpt(Foo)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(Foo)
            listener: handleImplements(null, 0)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(implemen)
          recoverySmallLookAheadSkipTokens(E, [{, with, implements])
            reportRecoverableError(implemen, Message[UnexpectedToken, Unexpected token 'implemen'., null, {lexeme: implemen}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'implemen'., null, {lexeme: implemen}], implemen, implemen)
          parseEnumWithClauseOpt(implemen)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(implemen)
            listener: handleImplements(null, 0)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(implements)
          parseEnumWithClauseOpt(E)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(E)
            listener: handleIdentifier(Foo, typeReference)
            listener: handleNoTypeArguments(w)
            listener: handleType(Foo, null)
            listener: handleImplements(implements, 1)
          recoveryEnumWith(Foo, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
          recoveryEnumImplements(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
          recoverySmallLookAheadSkipTokens(Foo, [{, with, implements])
            reportRecoverableError(w, Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(with)
          parseEnumWithClauseOpt(E)
            parseTypeList(with)
              listener: beginTypeList({)
              reportRecoverableErrorWithToken({, Instance of 'Template<(Token) => Message>')
                listener: handleRecoverableError(Message[ExpectedType, Expected a type, but got '{'., null, {lexeme: {}], {, {)
              rewriter()
              listener: handleIdentifier(, typeReference)
              listener: handleNoTypeArguments({)
              listener: handleType(, null)
              listener: endTypeList(1)
            listener: handleEnumWithClause(with)
          parseClassOrMixinOrEnumImplementsOpt()
            listener: handleImplements(null, 0)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(impl)
          recoverySmallLookAheadSkipTokens(E, [{, with, implements])
            reportRecoverableError(impl, Message[UnexpectedToken, Unexpected token 'impl'., null, {lexeme: impl}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'impl'., null, {lexeme: impl}], impl, impl)
          parseEnumWithClauseOpt(impl)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(impl)
            listener: handleIdentifier(Foo, typeReference)
            listener: handleNoTypeArguments({)
            listener: handleType(Foo, null)
            listener: handleImplements(implements, 1)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(with)
          parseEnumWithClauseOpt(E)
            parseTypeList(with)
              listener: beginTypeList(Foo)
              listener: handleIdentifier(Foo, typeReference)
              listener: handleNoTypeArguments(implements)
              listener: handleType(Foo, null)
              listener: endTypeList(1)
            listener: handleEnumWithClause(with)
          parseClassOrMixinOrEnumImplementsOpt(Foo)
            listener: handleIdentifier(Bar, typeReference)
            listener: handleNoTypeArguments({)
            listener: handleType(Bar, null)
            listener: handleImplements(implements, 1)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(implements)
          parseEnumWithClauseOpt(E)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(E)
            listener: handleIdentifier(Bar, typeReference)
            listener: handleNoTypeArguments(with)
            listener: handleType(Bar, null)
            listener: handleImplements(implements, 1)
          recoveryEnumWith(Bar, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
            reportRecoverableError(with, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
              listener: handleRecoverableError(Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}], with, with)
            parseEnumWithClauseOpt(Bar)
              parseTypeList(with)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(gunk1)
          recoverySmallLookAheadSkipTokens(E, [{, with, implements])
            reportRecoverableError(gunk1, Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}], gunk1, gunk1)
          parseEnumWithClauseOpt(gunk1)
            parseTypeList(with)
              listener: beginTypeList(Foo)
              listener: handleIdentifier(Foo, typeReference)
              listener: handleNoTypeArguments(gunk2)
              listener: handleType(Foo, null)
              listener: endTypeList(1)
            listener: handleEnumWithClause(with)
          recoveryEnumWith(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
          recoverySmallLookAheadSkipTokens(Foo, [{, with, implements])
            reportRecoverableError(gunk2, Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}], gunk2, gunk2)
          parseClassOrMixinOrEnumImplementsOpt(gunk2)
            listener: handleIdentifier(Bar, typeReference)
            listener: handleNoTypeArguments({)
            listener: handleType(Bar, null)
            listener: handleImplements(implements, 1)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(gunk1)
          recoverySmallLookAheadSkipTokens(E, [{, with, implements])
            reportRecoverableError(gunk1, Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}], gunk1, gunk1)
          parseEnumWithClauseOpt(gunk1)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(gunk1)
            listener: handleIdentifier(Bar, typeReference)
            listener: handleNoTypeArguments(gunk2)
            listener: handleType(Bar, null)
            listener: handleImplements(implements, 1)
          recoveryEnumWith(Bar, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
          recoveryEnumImplements(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
          recoverySmallLookAheadSkipTokens(Bar, [{, with, implements])
            reportRecoverableError(gunk2, Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}])
              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}], gunk2, gunk2)
          recoveryEnumWith(gunk2, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
            reportRecoverableError(with, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
              listener: handleRecoverableError(Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}], with, with)
            parseEnumWithClauseOpt(gunk2)
              parseTypeList(with)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(with)
          parseEnumWithClauseOpt(E)
            parseTypeList(with)
              listener: beginTypeList(Foo)
              listener: handleIdentifier(Foo, typeReference)
              listener: handleNoTypeArguments(with)
              listener: handleType(Foo, null)
              listener: endTypeList(1)
            listener: handleEnumWithClause(with)
          recoveryEnumWith(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
            reportRecoverableError(with, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}], with, with)
            parseEnumWithClauseOpt(Foo)
              parseTypeList(with)
          parseClassOrMixinOrEnumImplementsOpt(Foo2)
            listener: handleIdentifier(Bar, typeReference)
            listener: handleNoTypeArguments(implements)
            listener: handleType(Bar, null)
            listener: handleImplements(implements, 1)
          recoveryEnumWith(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
          recoveryEnumImplements(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
            reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements)
            parseClassOrMixinOrEnumImplementsOpt(Bar)
          recoveryEnumWith(Bar2, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
            reportRecoverableError(with, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}], with, with)
            parseEnumWithClauseOpt(Bar2)
              parseTypeList(with)
          recoveryEnumWith(Foo3, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
          recoveryEnumImplements(Foo3, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
            reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements)
            parseClassOrMixinOrEnumImplementsOpt(Foo3)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration(enum)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(enum)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext')
      parseEnum(enum)
        listener: beginUncategorizedTopLevelDeclaration(enum)
        ensureIdentifier(enum, enumDeclaration)
          listener: handleIdentifier(E, enumDeclaration)
        listener: beginEnum(enum)
        parseEnumHeaderOpt(E, enum)
          listener: handleNoTypeVariables(implements)
          parseEnumWithClauseOpt(E)
            listener: handleEnumNoWithClause()
          parseClassOrMixinOrEnumImplementsOpt(E)
            listener: handleIdentifier(Bar, typeReference)
            listener: handleNoTypeArguments(implements)
            listener: handleType(Bar, null)
            listener: handleImplements(implements, 1)
          recoveryEnumWith(Bar, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
          recoveryEnumImplements(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
            reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements)
            parseClassOrMixinOrEnumImplementsOpt(Bar)
          recoveryEnumWith(Bar2, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
            reportRecoverableError(with, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}])
              listener: handleRecoverableError(Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}], with, with)
            parseEnumWithClauseOpt(Bar2)
              parseTypeList(with)
          recoveryEnumWith(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
            reportRecoverableError(with, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}], with, with)
            parseEnumWithClauseOpt(Foo)
              parseTypeList(with)
          recoveryEnumWith(Foo2, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
          recoveryEnumImplements(Foo2, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
            reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements)
            parseClassOrMixinOrEnumImplementsOpt(Foo2)
          recoveryEnumWith(Bar3, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
            reportRecoverableError(with, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}])
              listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}], with, with)
            parseEnumWithClauseOpt(Bar3)
              parseTypeList(with)
        listener: handleEnumHeader(enum, {)
        parseEnumElement({)
          parseMetadataStar({)
            listener: beginMetadataStar(v)
            listener: endMetadataStar(0)
          ensureIdentifier({, enumValueDeclaration)
            listener: handleIdentifier(v, enumValueDeclaration)
          parseConstructorReference(v, ConstructorReferenceContext.Const, null, true)
            listener: handleNoTypeNameInConstructorReference(})
            listener: beginConstructorReference(v)
            listener: handleNoTypeArguments(})
            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(})
            listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
          listener: handleNoArguments(v)
          listener: handleEnumElement({)
        listener: handleEnumElements(}, 1)
        listener: endEnum(enum, {, 0)
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(enum)
  listener: endCompilationUnit(15, )