Problems reported:

parser/error_recovery/issue_48371:1:8: Unexpected token 'w'.
enum E w /*cursor, about to type 'with'*/ {
       ^

parser/error_recovery/issue_48371:5:8: Unexpected token 'w'.
enum E w /*cursor, about to type 'with'*/ implements Foo {
       ^

parser/error_recovery/issue_48371:9:23: The 'with' clause must come before the 'implements' clause.
enum E implements Foo with Bar {
                      ^^^^

parser/error_recovery/issue_48371:13:23: Each 'enum' definition can have at most one 'implements' clause.
enum E implements Foo implements Bar implements Bar2 {
                      ^^^^^^^^^^

parser/error_recovery/issue_48371:13:38: Each 'enum' definition can have at most one 'implements' clause.
enum E implements Foo implements Bar implements Bar2 {
                                     ^^^^^^^^^^

parser/error_recovery/issue_48371:17:8: Unexpected tokens.
enum E w /*cursor, about to type 'with' instead of implements*/ Foo {
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

parser/error_recovery/issue_48371:21:8: Unexpected token 'implemen'.
enum E implemen /*cursor, about to type 'implements'*/ {
       ^^^^^^^^

parser/error_recovery/issue_48371:25:23: Unexpected token 'w'.
enum E implements Foo w/*about to write 'with'*/ {
                      ^

parser/error_recovery/issue_48371:29:26: Expected a type, but got '{'.
enum E with /* cursor */ {
                         ^

parser/error_recovery/issue_48371:33:8: Unexpected token 'impl'.
enum E impl implements Foo {
       ^^^^

parser/error_recovery/issue_48371:43:23: The 'with' clause must come before the 'implements' clause.
enum E implements Bar with Foo {
                      ^^^^

parser/error_recovery/issue_48371:48:8: Unexpected token 'gunk1'.
enum E gunk1 with Foo gunk2 implements Bar {
       ^^^^^

parser/error_recovery/issue_48371:48:23: Unexpected token 'gunk2'.
enum E gunk1 with Foo gunk2 implements Bar {
                      ^^^^^

parser/error_recovery/issue_48371:53:8: Unexpected token 'gunk1'.
enum E gunk1 implements Bar gunk2 with Foo {
       ^^^^^

parser/error_recovery/issue_48371:53:29: Unexpected token 'gunk2'.
enum E gunk1 implements Bar gunk2 with Foo {
                            ^^^^^

parser/error_recovery/issue_48371:53:35: The 'with' clause must come before the 'implements' clause.
enum E gunk1 implements Bar gunk2 with Foo {
                                  ^^^^

parser/error_recovery/issue_48371:58:17: Each 'enum' definition can have at most one 'with' clause.
enum E with Foo with Foo2 implements Bar implements Bar2 with Foo3 implements Bar3 {
                ^^^^

parser/error_recovery/issue_48371:58:42: Each 'enum' definition can have at most one 'implements' clause.
enum E with Foo with Foo2 implements Bar implements Bar2 with Foo3 implements Bar3 {
                                         ^^^^^^^^^^

parser/error_recovery/issue_48371:58:58: Each 'enum' definition can have at most one 'with' clause.
enum E with Foo with Foo2 implements Bar implements Bar2 with Foo3 implements Bar3 {
                                                         ^^^^

parser/error_recovery/issue_48371:58:68: Each 'enum' definition can have at most one 'implements' clause.
enum E with Foo with Foo2 implements Bar implements Bar2 with Foo3 implements Bar3 {
                                                                   ^^^^^^^^^^

parser/error_recovery/issue_48371:63:23: Each 'enum' definition can have at most one 'implements' clause.
enum E implements Bar implements Bar2 with Foo with Foo2 implements Bar3 with Foo3 {
                      ^^^^^^^^^^

parser/error_recovery/issue_48371:63:39: The 'with' clause must come before the 'implements' clause.
enum E implements Bar implements Bar2 with Foo with Foo2 implements Bar3 with Foo3 {
                                      ^^^^

parser/error_recovery/issue_48371:63:48: Each 'enum' definition can have at most one 'with' clause.
enum E implements Bar implements Bar2 with Foo with Foo2 implements Bar3 with Foo3 {
                                               ^^^^

parser/error_recovery/issue_48371:63:58: Each 'enum' definition can have at most one 'implements' clause.
enum E implements Bar implements Bar2 with Foo with Foo2 implements Bar3 with Foo3 {
                                                         ^^^^^^^^^^

parser/error_recovery/issue_48371:63:74: Each 'enum' definition can have at most one 'with' clause.
enum E implements Bar implements Bar2 with Foo with Foo2 implements Bar3 with Foo3 {
                                                                         ^^^^

beginCompilationUnit(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(w)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w)
      handleEnumNoWithClause()
      handleImplements(null, 0)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(w)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w)
      handleEnumNoWithClause()
      handleIdentifier(Foo, typeReference)
      handleNoTypeArguments({)
      handleType(Foo, null)
      handleImplements(implements, 1)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(implements)
      handleEnumNoWithClause()
      handleIdentifier(Foo, typeReference)
      handleNoTypeArguments(with)
      handleType(Foo, null)
      handleImplements(implements, 1)
      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)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(implements)
      handleEnumNoWithClause()
      handleIdentifier(Foo, typeReference)
      handleNoTypeArguments(implements)
      handleType(Foo, null)
      handleImplements(implements, 1)
      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)
      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)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(w)
      handleRecoverableError(UnexpectedTokens, w, Foo)
      handleEnumNoWithClause()
      handleImplements(null, 0)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(implemen)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'implemen'., null, {lexeme: implemen}], implemen, implemen)
      handleEnumNoWithClause()
      handleImplements(null, 0)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(implements)
      handleEnumNoWithClause()
      handleIdentifier(Foo, typeReference)
      handleNoTypeArguments(w)
      handleType(Foo, null)
      handleImplements(implements, 1)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(with)
      beginTypeList({)
        handleRecoverableError(Message[ExpectedType, Expected a type, but got '{'., null, {lexeme: {}], {, {)
        handleIdentifier(, typeReference)
        handleNoTypeArguments({)
        handleType(, null)
      endTypeList(1)
      handleEnumWithClause(with)
      handleImplements(null, 0)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(impl)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'impl'., null, {lexeme: impl}], impl, impl)
      handleEnumNoWithClause()
      handleIdentifier(Foo, typeReference)
      handleNoTypeArguments({)
      handleType(Foo, null)
      handleImplements(implements, 1)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(with)
      beginTypeList(Foo)
        handleIdentifier(Foo, typeReference)
        handleNoTypeArguments(implements)
        handleType(Foo, null)
      endTypeList(1)
      handleEnumWithClause(with)
      handleIdentifier(Bar, typeReference)
      handleNoTypeArguments({)
      handleType(Bar, null)
      handleImplements(implements, 1)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(implements)
      handleEnumNoWithClause()
      handleIdentifier(Bar, typeReference)
      handleNoTypeArguments(with)
      handleType(Bar, null)
      handleImplements(implements, 1)
      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)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(gunk1)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}], gunk1, gunk1)
      beginTypeList(Foo)
        handleIdentifier(Foo, typeReference)
        handleNoTypeArguments(gunk2)
        handleType(Foo, null)
      endTypeList(1)
      handleEnumWithClause(with)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}], gunk2, gunk2)
      handleIdentifier(Bar, typeReference)
      handleNoTypeArguments({)
      handleType(Bar, null)
      handleImplements(implements, 1)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(gunk1)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}], gunk1, gunk1)
      handleEnumNoWithClause()
      handleIdentifier(Bar, typeReference)
      handleNoTypeArguments(gunk2)
      handleType(Bar, null)
      handleImplements(implements, 1)
      handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}], gunk2, gunk2)
      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)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(with)
      beginTypeList(Foo)
        handleIdentifier(Foo, typeReference)
        handleNoTypeArguments(with)
        handleType(Foo, null)
      endTypeList(1)
      handleEnumWithClause(with)
      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)
      handleIdentifier(Bar, typeReference)
      handleNoTypeArguments(implements)
      handleType(Bar, null)
      handleImplements(implements, 1)
      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)
      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)
      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)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration(enum)
  beginMetadataStar(enum)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(enum)
    handleIdentifier(E, enumDeclaration)
    beginEnum(enum)
      handleNoTypeVariables(implements)
      handleEnumNoWithClause()
      handleIdentifier(Bar, typeReference)
      handleNoTypeArguments(implements)
      handleType(Bar, null)
      handleImplements(implements, 1)
      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)
      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)
      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)
      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)
      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)
      handleEnumHeader(enum, {)
      beginMetadataStar(v)
      endMetadataStar(0)
      handleIdentifier(v, enumValueDeclaration)
      handleNoTypeNameInConstructorReference(})
      beginConstructorReference(v)
        handleNoTypeArguments(})
        handleNoConstructorReferenceContinuationAfterTypeArguments(})
      endConstructorReference(v, null, }, ConstructorReferenceContext.Const)
      handleNoArguments(v)
      handleEnumElement({)
      handleEnumElements(}, 1)
    endEnum(enum, {, 0)
  endTopLevelDeclaration()
endCompilationUnit(15, )