[parser][analyzer][cfe] Add parsing support for enhanced enums

Part of https://github.com/dart-lang/sdk/issues/47453.

Change-Id: I3a722cbcca6323b751eb3b2429bb9ffb642972b7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/217011
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Chloe Stefantsova <cstefantsova@google.com>

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -2767,6 +2767,16 @@ const MessageCode messageEnumDeclarationEmpty = const MessageCode(
     analyzerCodes: <String>["EMPTY_ENUM_BODY"],
     problemMessage: r"""An enum declaration can't be empty.""");
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeEnumDeclaresFactory = messageEnumDeclaresFactory;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageEnumDeclaresFactory = const MessageCode(
+    "EnumDeclaresFactory",
+    problemMessage: r"""Enums can't declare factory constructors.""",
+    correctionMessage:
+        r"""Try removing the factory constructor declaration.""");
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeEnumInClass = messageEnumInClass;
 
@@ -5660,6 +5670,17 @@ Message _withArgumentsInternalProblemNotFoundIn(String name, String name2) {
       arguments: {'name': name, 'name2': name2});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeInternalProblemOmittedTypeNameInConstructorReference =
+    messageInternalProblemOmittedTypeNameInConstructorReference;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageInternalProblemOmittedTypeNameInConstructorReference =
+    const MessageCode("InternalProblemOmittedTypeNameInConstructorReference",
+        severity: Severity.internalProblem,
+        problemMessage:
+            r"""Unsupported omission of the type name in a constructor reference outside of an enum element declaration.""");
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeInternalProblemPreviousTokenNotFound =
     messageInternalProblemPreviousTokenNotFound;

pkg/_fe_analyzer_shared/lib/src/parser/declaration_kind.dart

@@ -14,4 +14,7 @@ enum DeclarationKind {
 
   /// An extension declaration.
   Extension,
+
+  /// An enum.
+  Enum,
 }

pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart

@@ -636,8 +636,66 @@ class ForwardingListener implements Listener {
   }
 
   @override
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
-    listener?.endEnum(enumKeyword, leftBrace, count);
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
+    listener?.endEnum(enumKeyword, leftBrace, memberCount);
+  }
+
+  @override
+  void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    listener?.endEnumConstructor(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken);
+  }
+
+  @override
+  void handleEnumElement(Token beginToken) {
+    listener?.handleEnumElement(beginToken);
+  }
+
+  @override
+  void handleEnumElements(Token elementsEndToken, int elementsCount) {
+    listener?.handleEnumElements(elementsEndToken, elementsCount);
+  }
+
+  @override
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    listener?.handleEnumHeader(enumKeyword, leftBrace);
+  }
+
+  @override
+  void endEnumFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    listener?.endEnumFactoryMethod(beginToken, factoryKeyword, endToken);
+  }
+
+  @override
+  void endEnumFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    listener?.endClassFields(
+        abstractToken,
+        externalToken,
+        staticToken,
+        covariantToken,
+        lateToken,
+        varFinalOrConst,
+        count,
+        beginToken,
+        endToken);
+  }
+
+  @override
+  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    listener?.endEnumMethod(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken);
   }
 
   @override
@@ -1173,9 +1231,13 @@ class ForwardingListener implements Listener {
   }
 
   @override
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
-    listener?.handleClassOrMixinImplements(implementsKeyword, interfacesCount);
+  void handleEnumNoWithClause() {
+    listener?.handleEnumNoWithClause();
+  }
+
+  @override
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
+    listener?.handleImplements(implementsKeyword, interfacesCount);
   }
 
   @override
@@ -1190,6 +1252,11 @@ class ForwardingListener implements Listener {
     listener?.handleClassWithClause(withKeyword);
   }
 
+  @override
+  void handleEnumWithClause(Token withKeyword) {
+    listener?.handleEnumWithClause(withKeyword);
+  }
+
   @override
   void handleCommentReference(
       Token? newKeyword, Token? prefix, Token? period, Token token) {
@@ -1547,6 +1614,11 @@ class ForwardingListener implements Listener {
     listener?.handleNoTypeArguments(token);
   }
 
+  @override
+  void handleNoTypeNameInConstructorReference(Token token) {
+    listener?.handleNoTypeNameInConstructorReference(token);
+  }
+
   @override
   void handleNoTypeVariables(Token token) {
     listener?.handleNoTypeVariables(token);

pkg/_fe_analyzer_shared/lib/src/parser/listener.dart

@@ -137,12 +137,11 @@ class Listener implements UnescapeErrorListener {
     logEvent("ClassExtends");
   }
 
-  /// Handle an implements clause in a class or mixin declaration.
+  /// Handle an implements clause in a class, mixin or enum declaration.
   /// Substructures:
   /// - implemented types
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
-    logEvent("ClassImplements");
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
+    logEvent("Implements");
   }
 
   /// Handle a show clause in an extension declaration.
@@ -306,12 +305,55 @@ class Listener implements UnescapeErrorListener {
   void beginEnum(Token enumKeyword) {}
 
   /// Handle the end of an enum declaration.  Substructures:
+  /// - [memberCount] times:
+  ///   - Enum member
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
+    logEvent("Enum");
+  }
+
+  /// Handle the end of an enum constructor declaration.  Substructures:
+  /// - metadata
+  /// - return type
+  /// - method name (identifier, possibly qualified)
+  /// - type variables
+  /// - formal parameters
+  /// - initializers
+  /// - async marker
+  /// - body
+  void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    // TODO(danrubel): push implementation into subclasses
+    endClassMethod(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken);
+  }
+
+  /// Handle the enum elements. Substructures:
+  /// - [elementsCount] times:
+  ///   - Enum element
+  void handleEnumElements(Token elementsEndToken, int elementsCount) {
+    logEvent("EnumElements");
+  }
+
+  /// Handle the header of an enum declaration.  Substructures:
   /// - Metadata
   /// - Enum name (identifier)
-  /// - [count] times:
-  ///   - Enum value (identifier)
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
-    logEvent("Enum");
+  /// - type variables
+  /// - with clause
+  /// - implemented types
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    logEvent("EnumHeader");
+  }
+
+  /// Handle the enum element. Substructures:
+  /// - Metadata
+  /// - Enum value (identifier)
+  void handleEnumElement(Token beginToken) {
+    logEvent("EnumElement");
+  }
+
+  void endEnumFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    endClassFactoryMethod(beginToken, factoryKeyword, endToken);
   }
 
   void beginExport(Token token) {}
@@ -448,6 +490,42 @@ class Listener implements UnescapeErrorListener {
         lateToken, varFinalOrConst, count, beginToken, endToken);
   }
 
+  /// Handle the end of an enum field declaration.  Substructures:
+  /// - Metadata
+  /// - Modifiers
+  /// - Type
+  /// - Variable declarations (count times)
+  ///
+  /// Started by [beginFields].
+  void endEnumFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    endClassFields(abstractToken, externalToken, staticToken, covariantToken,
+        lateToken, varFinalOrConst, count, beginToken, endToken);
+  }
+
+  /// Handle the end of an enum method declaration.  Substructures:
+  /// - metadata
+  /// - return type
+  /// - method name (identifier, possibly qualified)
+  /// - type variables
+  /// - formal parameters
+  /// - initializers
+  /// - async marker
+  /// - body
+  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    endClassMethod(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken);
+  }
+
   /// Marks that the grammar term `forInitializerStatement` has been parsed and
   /// it was an empty statement.
   void handleForInitializerEmptyStatement(Token token) {
@@ -609,18 +687,33 @@ class Listener implements UnescapeErrorListener {
     logEvent("FunctionTypeAlias");
   }
 
-  /// Handle the end of a with clause (e.g. "with B, C").
+  /// Handle the end of a class with clause (e.g. "with B, C").
   /// Substructures:
   /// - mixin types (TypeList)
   void handleClassWithClause(Token withKeyword) {
     logEvent("ClassWithClause");
   }
 
-  /// Handle the absence of a with clause.
+  /// Handle the absence of a class with clause.
   void handleClassNoWithClause() {
     logEvent("ClassNoWithClause");
   }
 
+  /// Handle the end of an enum with clause (e.g. "with B, C").
+  /// Substructures:
+  /// - mixin types (TypeList)
+  ///
+  /// This method is separated from [handleClassWithClause] to simplify
+  /// handling the different objects in the context.
+  void handleEnumWithClause(Token withKeyword) {
+    logEvent("EnumWithClause");
+  }
+
+  /// Handle the absence of an enum with clause.
+  void handleEnumNoWithClause() {
+    logEvent("EnumNoWithClause");
+  }
+
   /// Handle the beginning of a named mixin application.
   /// [beginToken] may be the same as [name], or may point to modifiers
   /// (or extraneous modifiers in the case of recovery) preceding [name].
@@ -1567,6 +1660,10 @@ class Listener implements UnescapeErrorListener {
     logEvent("NoConstructorReferenceContinuationAfterTypeArguments");
   }
 
+  void handleNoTypeNameInConstructorReference(Token token) {
+    logEvent("NoTypeNameInConstructorReference");
+  }
+
   void handleNoType(Token lastConsumed) {
     logEvent("NoType");
   }

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -1286,7 +1286,7 @@ class Parser {
     return token;
   }
 
-  Token parseWithClauseOpt(Token token) {
+  Token parseClassWithClauseOpt(Token token) {
     // <mixins> ::= with <typeNotVoidList>
     Token withKeyword = token.next!;
     if (optional('with', withKeyword)) {
@@ -1298,6 +1298,18 @@ class Parser {
     return token;
   }
 
+  Token parseEnumWithClauseOpt(Token token) {
+    // <mixins> ::= with <typeNotVoidList>
+    Token withKeyword = token.next!;
+    if (optional('with', withKeyword)) {
+      token = parseTypeList(withKeyword);
+      listener.handleEnumWithClause(withKeyword);
+    } else {
+      listener.handleEnumNoWithClause();
+    }
+    return token;
+  }
+
   /// Parse the formal parameters of a getter (which shouldn't have parameters)
   /// or function or method.
   Token parseGetterOrFormalParameters(
@@ -1930,35 +1942,45 @@ class Parser {
 
   /// ```
   /// enumType:
-  ///   metadata 'enum' id '{' metadata id [',' metadata id]* [','] '}'
-  /// ;
+  ///   metadata 'enum' id typeParameters? mixins? interfaces? '{'
+  ///      enumEntry (',' enumEntry)* (',')? (';'
+  ///      (metadata classMemberDefinition)*
+  ///      )?
+  ///   '}'
+  ///
+  /// enumEntry:
+  ///     metadata id argumentPart?
+  ///   | metadata id typeArguments? '.' id arguments
   /// ```
   Token parseEnum(Token enumKeyword) {
     assert(optional('enum', enumKeyword));
     listener.beginUncategorizedTopLevelDeclaration(enumKeyword);
-    listener.beginEnum(enumKeyword);
     Token token =
         ensureIdentifier(enumKeyword, IdentifierContext.enumDeclaration);
+    String name = token.lexeme;
+    listener.beginEnum(enumKeyword);
+    token = parseEnumHeaderOpt(token, enumKeyword);
     Token leftBrace = token.next!;
-    int count = 0;
+    int elementCount = 0;
+    int memberCount = 0;
     if (optional('{', leftBrace)) {
+      listener.handleEnumHeader(enumKeyword, leftBrace);
       token = leftBrace;
       while (true) {
         Token next = token.next!;
-        if (optional('}', next)) {
+        if (optional('}', next) || optional(';', next)) {
           token = next;
-          if (count == 0) {
+          if (elementCount == 0) {
             reportRecoverableError(token, codes.messageEnumDeclarationEmpty);
           }
           break;
         }
-        token = parseMetadataStar(token);
-        token = ensureIdentifier(token, IdentifierContext.enumValueDeclaration);
+        token = parseEnumElement(token);
         next = token.next!;
-        count++;
+        elementCount++;
         if (optional(',', next)) {
           token = next;
-        } else if (optional('}', next)) {
+        } else if (optional('}', next) || optional(';', next)) {
           token = next;
           break;
         } else {
@@ -1984,14 +2006,51 @@ class Parser {
           }
         }
       }
+      listener.handleEnumElements(token, elementCount);
+      if (optional(';', token)) {
+        while (notEofOrValue('}', token.next!)) {
+          token = parseClassOrMixinOrExtensionOrEnumMemberImpl(
+              token, DeclarationKind.Enum, name);
+          ++memberCount;
+        }
+        token = token.next!;
+        assert(token.isEof || optional('}', token));
+      }
     } else {
       // TODO(danrubel): merge this error message with missing class/mixin body
       leftBrace = ensureBlock(
           token, codes.templateExpectedEnumBody, /* missingBlockName = */ null);
+      listener.handleEnumHeader(enumKeyword, leftBrace);
+      listener.handleEnumElements(token, elementCount);
       token = leftBrace.endGroup!;
     }
     assert(optional('}', token));
-    listener.endEnum(enumKeyword, leftBrace, count);
+    listener.endEnum(enumKeyword, leftBrace, memberCount);
+    return token;
+  }
+
+  Token parseEnumHeaderOpt(Token token, Token enumKeyword) {
+    token = computeTypeParamOrArg(
+            token, /* inDeclaration = */ true, /* allowsVariance = */ true)
+        .parseVariables(token, this);
+    token = parseEnumWithClauseOpt(token);
+    token = parseClassOrMixinOrEnumImplementsOpt(token);
+    return token;
+  }
+
+  Token parseEnumElement(Token token) {
+    Token beginToken = token;
+    token = parseMetadataStar(token);
+    token = ensureIdentifier(token, IdentifierContext.enumValueDeclaration);
+    token = parseConstructorReference(token, ConstructorReferenceContext.Const,
+        /* typeArg = */ null, /* isImplicitTypeName = */ true);
+    Token next = token.next!;
+    if (optional('(', next) || optional('<', next)) {
+      token = parseConstructorInvocationArguments(token);
+    } else {
+      listener.handleNoArguments(token);
+    }
+    listener.handleEnumElement(beginToken);
     return token;
   }
 
@@ -2060,8 +2119,8 @@ class Parser {
 
   Token parseClassHeaderOpt(Token token, Token begin, Token classKeyword) {
     token = parseClassExtendsOpt(token);
-    token = parseWithClauseOpt(token);
-    token = parseClassOrMixinImplementsOpt(token);
+    token = parseClassWithClauseOpt(token);
+    token = parseClassOrMixinOrEnumImplementsOpt(token);
     Token? nativeToken;
     if (optional('native', token.next!)) {
       nativeToken = token.next!;
@@ -2127,7 +2186,7 @@ class Parser {
         }
       }
 
-      token = parseWithClauseOpt(token);
+      token = parseClassWithClauseOpt(token);
 
       if (recoveryListener.withKeyword != null) {
         if (hasWith) {
@@ -2142,7 +2201,7 @@ class Parser {
         }
       }
 
-      token = parseClassOrMixinImplementsOpt(token);
+      token = parseClassOrMixinOrEnumImplementsOpt(token);
 
       if (recoveryListener.implementsKeyword != null) {
         if (hasImplements) {
@@ -2204,7 +2263,7 @@ class Parser {
   ///   'implements' typeName (',' typeName)*
   /// ;
   /// ```
-  Token parseClassOrMixinImplementsOpt(Token token) {
+  Token parseClassOrMixinOrEnumImplementsOpt(Token token) {
     Token? implementsKeyword;
     int interfacesCount = 0;
     if (optional('implements', token.next!)) {
@@ -2215,7 +2274,7 @@ class Parser {
         ++interfacesCount;
       } while (optional(',', token.next!));
     }
-    listener.handleClassOrMixinImplements(implementsKeyword, interfacesCount);
+    listener.handleImplements(implementsKeyword, interfacesCount);
     return token;
   }
 
@@ -2250,7 +2309,7 @@ class Parser {
 
   Token parseMixinHeaderOpt(Token token, Token mixinKeyword) {
     token = parseMixinOnOpt(token);
-    token = parseClassOrMixinImplementsOpt(token);
+    token = parseClassOrMixinOrEnumImplementsOpt(token);
     listener.handleMixinHeader(mixinKeyword);
     return token;
   }
@@ -2307,7 +2366,7 @@ class Parser {
         }
       }
 
-      token = parseClassOrMixinImplementsOpt(token);
+      token = parseClassOrMixinOrEnumImplementsOpt(token);
 
       if (recoveryListener.implementsKeyword != null) {
         if (hasImplements) {
@@ -3006,6 +3065,18 @@ class Parser {
             beforeStart.next!,
             token);
         break;
+      case DeclarationKind.Enum:
+        listener.endEnumFields(
+            abstractToken,
+            externalToken,
+            staticToken,
+            covariantToken,
+            lateToken,
+            varFinalOrConst,
+            fieldCount,
+            beforeStart.next!,
+            token);
+        break;
     }
     return token;
   }
@@ -3550,7 +3621,7 @@ class Parser {
     listener.beginClassOrMixinOrExtensionBody(kind, token);
     int count = 0;
     while (notEofOrValue('}', token.next!)) {
-      token = parseClassOrMixinOrExtensionMemberImpl(
+      token = parseClassOrMixinOrExtensionOrEnumMemberImpl(
           token, kind, enclosingDeclarationName);
       ++count;
     }
@@ -3572,7 +3643,7 @@ class Parser {
   /// token and returns the token after the last consumed token rather than the
   /// last consumed token.
   Token parseClassMember(Token token, String? className) {
-    return parseClassOrMixinOrExtensionMemberImpl(
+    return parseClassOrMixinOrExtensionOrEnumMemberImpl(
             syntheticPreviousToken(token), DeclarationKind.Class, className)
         .next!;
   }
@@ -3584,7 +3655,7 @@ class Parser {
   /// token and returns the token after the last consumed token rather than the
   /// last consumed token.
   Token parseMixinMember(Token token, String mixinName) {
-    return parseClassOrMixinOrExtensionMemberImpl(
+    return parseClassOrMixinOrExtensionOrEnumMemberImpl(
             syntheticPreviousToken(token), DeclarationKind.Mixin, mixinName)
         .next!;
   }
@@ -3596,8 +3667,10 @@ class Parser {
   /// token and returns the token after the last consumed token rather than the
   /// last consumed token.
   Token parseExtensionMember(Token token, String extensionName) {
-    return parseClassOrMixinOrExtensionMemberImpl(syntheticPreviousToken(token),
-            DeclarationKind.Extension, extensionName)
+    return parseClassOrMixinOrExtensionOrEnumMemberImpl(
+            syntheticPreviousToken(token),
+            DeclarationKind.Extension,
+            extensionName)
         .next!;
   }
 
@@ -3636,7 +3709,7 @@ class Parser {
   ///   methodDeclaration
   /// ;
   /// ```
-  Token parseClassOrMixinOrExtensionMemberImpl(
+  Token parseClassOrMixinOrExtensionOrEnumMemberImpl(
       Token token, DeclarationKind kind, String? enclosingDeclarationName) {
     Token beforeStart = token = parseMetadataStar(token);
 
@@ -4160,6 +4233,10 @@ class Parser {
           break;
         case DeclarationKind.TopLevel:
           throw "Internal error: TopLevel constructor.";
+        case DeclarationKind.Enum:
+          listener.endEnumConstructor(getOrSet, beforeStart.next!,
+              beforeParam.next!, beforeInitializers?.next, token);
+          break;
       }
     } else {
       //
@@ -4189,6 +4266,10 @@ class Parser {
           break;
         case DeclarationKind.TopLevel:
           throw "Internal error: TopLevel method.";
+        case DeclarationKind.Enum:
+          listener.endEnumMethod(getOrSet, beforeStart.next!, beforeParam.next!,
+              beforeInitializers?.next, token);
+          break;
       }
     }
     return token;
@@ -4281,6 +4362,11 @@ class Parser {
         break;
       case DeclarationKind.TopLevel:
         throw "Internal error: TopLevel factory.";
+      case DeclarationKind.Enum:
+        reportRecoverableError(
+            factoryKeyword, codes.messageEnumDeclaresFactory);
+        listener.endEnumFactoryMethod(beforeStart.next!, factoryKeyword, token);
+        break;
     }
     return token;
   }
@@ -4404,12 +4490,19 @@ class Parser {
 
   Token parseConstructorReference(
       Token token, ConstructorReferenceContext constructorReferenceContext,
-      [TypeParamOrArgInfo? typeArg]) {
-    Token start =
-        ensureIdentifier(token, IdentifierContext.constructorReference);
+      [TypeParamOrArgInfo? typeArg, bool isImplicitTypeName = false]) {
+    Token start;
+    if (isImplicitTypeName) {
+      listener.handleNoTypeNameInConstructorReference(token.next!);
+      start = token;
+    } else {
+      start = ensureIdentifier(token, IdentifierContext.constructorReference);
+    }
     listener.beginConstructorReference(start);
-    token = parseQualifiedRestOpt(
-        start, IdentifierContext.constructorReferenceContinuation);
+    if (!isImplicitTypeName) {
+      token = parseQualifiedRestOpt(
+          start, IdentifierContext.constructorReferenceContinuation);
+    }
     typeArg ??= computeTypeParamOrArg(token);
     token = typeArg.parseArguments(token, this);
     Token? period = null;
@@ -6063,8 +6156,8 @@ class Parser {
     }
 
     listener.beginNewExpression(newKeyword);
-    token = parseConstructorReference(
-        newKeyword, ConstructorReferenceContext.New, potentialTypeArg);
+    token = parseConstructorReference(newKeyword,
+        ConstructorReferenceContext.New, /* typeArg = */ potentialTypeArg);
     token = parseConstructorInvocationArguments(token);
     listener.endNewExpression(newKeyword);
     return token;
@@ -6075,7 +6168,7 @@ class Parser {
     Token begin = token.next!; // This is the class name.
     listener.beginImplicitCreationExpression(begin);
     token = parseConstructorReference(
-        token, ConstructorReferenceContext.Implicit, typeArg);
+        token, ConstructorReferenceContext.Implicit, /* typeArg = */ typeArg);
     token = parseConstructorInvocationArguments(token);
     listener.endImplicitCreationExpression(begin, openAngleBracket);
     return token;
@@ -6191,8 +6284,8 @@ class Parser {
       }
     }
     listener.beginConstExpression(constKeyword);
-    token = parseConstructorReference(
-        token, ConstructorReferenceContext.Const, potentialTypeArg);
+    token = parseConstructorReference(token, ConstructorReferenceContext.Const,
+        /* typeArg = */ potentialTypeArg);
     token = parseConstructorInvocationArguments(token);
     listener.endConstExpression(constKeyword);
     return token;

pkg/_fe_analyzer_shared/lib/src/parser/recovery_listeners.dart

@@ -24,10 +24,9 @@ class ClassHeaderRecoveryListener extends ForwardingListener {
   }
 
   @override
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
     this.implementsKeyword = implementsKeyword;
-    super.handleClassOrMixinImplements(implementsKeyword, interfacesCount);
+    super.handleImplements(implementsKeyword, interfacesCount);
   }
 
   @override
@@ -82,10 +81,9 @@ class MixinHeaderRecoveryListener extends ForwardingListener {
   }
 
   @override
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
     this.implementsKeyword = implementsKeyword;
-    super.handleClassOrMixinImplements(implementsKeyword, interfacesCount);
+    super.handleImplements(implementsKeyword, interfacesCount);
   }
 
   @override

pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart

@@ -37,6 +37,7 @@ enum NullValue {
   ConditionallySelectedImport,
   ConstructorInitializerSeparator,
   ConstructorInitializers,
+  ConstructorReference,
   ConstructorReferenceContinuationAfterTypeArguments,
   ContinueTarget,
   Deferred,
@@ -346,9 +347,8 @@ abstract class StackListener extends Listener {
   }
 
   @override
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
-    debugEvent("ClassImplements");
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
+    debugEvent("Implements");
   }
 
   @override

pkg/analyzer/lib/dart/analysis/features.dart

@@ -23,6 +23,9 @@ abstract class Feature {
   static final control_flow_collections =
       ExperimentalFeatures.control_flow_collections;
 
+  /// Feature information for enhanced enums.
+  static final enhanced_enums = ExperimentalFeatures.enhanced_enums;
+
   /// Feature information for extension methods.
   static final extension_methods = ExperimentalFeatures.extension_methods;
 

pkg/analyzer/lib/dart/ast/ast.dart

@@ -1593,6 +1593,9 @@ abstract class EnumDeclaration implements NamedCompilationUnitMember {
   /// Return the left curly bracket.
   Token get leftBracket;
 
+  /// Return the members declared by the enumeration.
+  NodeList<ClassMember> get members;
+
   @override
   SimpleIdentifier get name;
 

pkg/analyzer/lib/dart/ast/ast_factory.dart

@@ -308,6 +308,7 @@ abstract class AstFactory {
       SimpleIdentifier name,
       Token leftBracket,
       List<EnumConstantDeclaration> constants,
+      List<ClassMember> members,
       Token rightBracket);
 
   /// Returns a newly created export directive. Either or both of the

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -3301,6 +3301,9 @@ class EnumDeclarationImpl extends NamedCompilationUnitMemberImpl
   /// The enumeration constants being declared.
   final NodeListImpl<EnumConstantDeclaration> _constants = NodeListImpl._();
 
+  /// The members defined by the enum.
+  final NodeListImpl<ClassMember> _members = NodeListImpl._();
+
   /// The right curly bracket.
   @override
   Token rightBracket;
@@ -3316,9 +3319,11 @@ class EnumDeclarationImpl extends NamedCompilationUnitMemberImpl
       SimpleIdentifierImpl name,
       this.leftBracket,
       List<EnumConstantDeclaration> constants,
+      List<ClassMember> members,
       this.rightBracket)
       : super(comment, metadata, name) {
     _constants._initialize(this, constants);
+    _members._initialize(this, members);
   }
 
   @override
@@ -3328,6 +3333,7 @@ class EnumDeclarationImpl extends NamedCompilationUnitMemberImpl
     ..add(_name)
     ..add(leftBracket)
     ..addAll(_constants)
+    ..addAll(_members)
     ..add(rightBracket);
 
   @override
@@ -3342,6 +3348,9 @@ class EnumDeclarationImpl extends NamedCompilationUnitMemberImpl
   @override
   Token get firstTokenAfterCommentAndMetadata => enumKeyword;
 
+  @override
+  NodeListImpl<ClassMember> get members => _members;
+
   @override
   E? accept<E>(AstVisitor<E> visitor) => visitor.visitEnumDeclaration(this);
 
@@ -3350,6 +3359,7 @@ class EnumDeclarationImpl extends NamedCompilationUnitMemberImpl
     super.visitChildren(visitor);
     _name.accept(visitor);
     _constants.accept(visitor);
+    _members.accept(visitor);
   }
 }
 

pkg/analyzer/lib/src/dart/ast/ast_factory.dart

@@ -391,9 +391,17 @@ class AstFactoryImpl extends AstFactory {
           SimpleIdentifier name,
           Token leftBracket,
           List<EnumConstantDeclaration> constants,
+          List<ClassMember> members,
           Token rightBracket) =>
-      EnumDeclarationImpl(comment as CommentImpl?, metadata, enumKeyword,
-          name as SimpleIdentifierImpl, leftBracket, constants, rightBracket);
+      EnumDeclarationImpl(
+          comment as CommentImpl?,
+          metadata,
+          enumKeyword,
+          name as SimpleIdentifierImpl,
+          leftBracket,
+          constants,
+          members,
+          rightBracket);
 
   @override
   ExportDirectiveImpl exportDirective(

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -62,6 +62,8 @@ import 'package:analyzer/src/dart/ast/ast.dart'
     show
         ClassDeclarationImpl,
         CompilationUnitImpl,
+        ConstructorNameImpl,
+        EnumDeclarationImpl,
         ExtensionDeclarationImpl,
         ImportDirectiveImpl,
         MethodInvocationImpl,
@@ -104,6 +106,9 @@ class AstBuilder extends StackListener {
   /// The extension currently being parsed, or `null` if none.
   ExtensionDeclarationImpl? extensionDeclaration;
 
+  /// The enum currently being parsed, or `null` if none.
+  EnumDeclarationImpl? enumDeclaration;
+
   /// If true, this is building a full AST. Otherwise, only create method
   /// bodies.
   final bool isFullAst;
@@ -153,6 +158,9 @@ class AstBuilder extends StackListener {
   /// `true` if super parameters are enabled
   final bool enableSuperParameters;
 
+  /// `true` if enhanced enums are enabled
+  final bool enableEnhancedEnums;
+
   final FeatureSet _featureSet;
 
   AstBuilder(ErrorReporter? errorReporter, this.fileUri, this.isFullAst,
@@ -174,6 +182,7 @@ class AstBuilder extends StackListener {
         enableNamedArgumentsAnywhere =
             _featureSet.isEnabled(Feature.named_arguments_anywhere),
         enableSuperParameters = _featureSet.isEnabled(Feature.super_parameters),
+        enableEnhancedEnums = _featureSet.isEnabled(Feature.enhanced_enums),
         uri = uri ?? fileUri;
 
   NodeList<ClassMember> get currentDeclarationMembers {
@@ -181,8 +190,10 @@ class AstBuilder extends StackListener {
       return classDeclaration!.members;
     } else if (mixinDeclaration != null) {
       return mixinDeclaration!.members;
-    } else {
+    } else if (extensionDeclaration != null) {
       return extensionDeclaration!.members;
+    } else {
+      return enumDeclaration!.members;
     }
   }
 
@@ -191,8 +202,10 @@ class AstBuilder extends StackListener {
       return classDeclaration!.name;
     } else if (mixinDeclaration != null) {
       return mixinDeclaration!.name;
-    } else {
+    } else if (extensionDeclaration != null) {
       return extensionDeclaration!.name;
+    } else {
+      return enumDeclaration!.name;
     }
   }
 
@@ -239,6 +252,9 @@ class AstBuilder extends StackListener {
     push(token);
   }
 
+  @override
+  void beginEnum(Token enumKeyword) {}
+
   @override
   void beginExtensionDeclaration(Token extensionKeyword, Token? nameToken) {
     assert(optional('extension', extensionKeyword));
@@ -334,11 +350,7 @@ class AstBuilder extends StackListener {
     }
     if (staticToken != null) {
       assert(staticToken.isModifier);
-      String? className = classDeclaration != null
-          ? classDeclaration!.name.name
-          : (mixinDeclaration != null
-              ? mixinDeclaration!.name.name
-              : extensionDeclaration!.name?.name);
+      String? className = currentDeclarationName?.name;
       if (name.lexeme != className || getOrSet != null) {
         modifiers.staticKeyword = staticToken;
       }
@@ -1177,17 +1189,18 @@ class AstBuilder extends StackListener {
   }
 
   @override
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
     assert(optional('enum', enumKeyword));
     assert(optional('{', leftBrace));
     debugEvent("Enum");
+  }
 
-    var constants = popTypedList2<EnumConstantDeclaration>(count);
-    var name = pop() as SimpleIdentifier;
-    var metadata = pop() as List<Annotation>?;
-    var comment = _findComment(metadata, enumKeyword);
-    declarations.add(ast.enumDeclaration(comment, metadata, enumKeyword, name,
-        leftBrace, constants, leftBrace.endGroup!));
+  @override
+  void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    debugEvent("endEnumConstructor");
+    endClassConstructor(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken);
   }
 
   @override
@@ -2646,20 +2659,6 @@ class AstBuilder extends StackListener {
     push(NullValue.WithClause);
   }
 
-  @override
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
-    assert(optionalOrNull('implements', implementsKeyword));
-    debugEvent("ClassImplements");
-
-    if (implementsKeyword != null) {
-      var interfaces = popTypedList2<NamedType>(interfacesCount);
-      push(ast.implementsClause(implementsKeyword, interfaces));
-    } else {
-      push(NullValue.IdentifierList);
-    }
-  }
-
   @override
   void handleClassWithClause(Token withKeyword) {
     assert(optional('with', withKeyword));
@@ -2735,6 +2734,101 @@ class AstBuilder extends StackListener {
     push(ast.emptyStatement(semicolon));
   }
 
+  @override
+  void handleEnumElement(Token beginToken) {
+    debugEvent("EnumElement");
+    var arguments = pop() as MethodInvocationImpl?;
+    var constructorName = pop() as ConstructorNameImpl?;
+
+    if (!enableEnhancedEnums &&
+        (arguments != null ||
+            constructorName != null &&
+                (constructorName.type2.typeArguments != null ||
+                    constructorName.name != null))) {
+      Token token = arguments != null
+          ? arguments.argumentList.beginToken
+          : constructorName!.beginToken;
+      var feature = ExperimentalFeatures.enhanced_enums;
+      handleRecoverableError(
+        templateExperimentNotEnabled.withArguments(
+          feature.enableString,
+          _versionAsString(ExperimentStatus.currentVersion),
+        ),
+        token,
+        token,
+      );
+    }
+  }
+
+  @override
+  void handleEnumElements(Token elementsEndToken, int elementsCount) {
+    debugEvent("EnumElements");
+
+    var constants = popTypedList2<EnumConstantDeclaration>(elementsCount);
+    enumDeclaration!.constants.addAll(constants);
+
+    if (!enableEnhancedEnums && optional(';', elementsEndToken)) {
+      var feature = ExperimentalFeatures.enhanced_enums;
+      handleRecoverableError(
+        templateExperimentNotEnabled.withArguments(
+          feature.enableString,
+          _versionAsString(ExperimentStatus.currentVersion),
+        ),
+        elementsEndToken,
+        elementsEndToken,
+      );
+    }
+  }
+
+  @override
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    assert(optional('enum', enumKeyword));
+    assert(optional('{', leftBrace));
+    debugEvent("EnumHeader");
+
+    var implementsClause = pop(NullValue.IdentifierList) as ImplementsClause?;
+    var withClause = pop(NullValue.WithClause) as WithClause?;
+    var typeParameters = pop() as TypeParameterList?;
+    var name = pop() as SimpleIdentifier;
+    var metadata = pop() as List<Annotation>?;
+    var comment = _findComment(metadata, enumKeyword);
+
+    if (!enableEnhancedEnums &&
+        (withClause != null ||
+            implementsClause != null ||
+            typeParameters != null)) {
+      var token = withClause != null
+          ? withClause.withKeyword
+          : implementsClause != null
+              ? implementsClause.implementsKeyword
+              : typeParameters!.beginToken;
+      var feature = ExperimentalFeatures.enhanced_enums;
+      handleRecoverableError(
+        templateExperimentNotEnabled.withArguments(
+          feature.enableString,
+          _versionAsString(ExperimentStatus.currentVersion),
+        ),
+        token,
+        token,
+      );
+    }
+
+    declarations.add(enumDeclaration = ast.enumDeclaration(comment, metadata,
+        enumKeyword, name, leftBrace, [], [], leftBrace.endGroup!));
+  }
+
+  @override
+  void handleEnumNoWithClause() {
+    push(NullValue.WithClause);
+  }
+
+  @override
+  void handleEnumWithClause(Token withKeyword) {
+    assert(optional('with', withKeyword));
+    var mixinTypes = pop() as List<NamedType>;
+    push(ast.withClause(withKeyword, mixinTypes));
+  }
+
   @override
   void handleErrorToken(ErrorToken token) {
     translateErrorToken(token, errorReporter.reportScannerError);
@@ -2962,6 +3056,19 @@ class AstBuilder extends StackListener {
     push(popTypedList<SimpleIdentifier>(count) ?? NullValue.IdentifierList);
   }
 
+  @override
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
+    assert(optionalOrNull('implements', implementsKeyword));
+    debugEvent("Implements");
+
+    if (implementsKeyword != null) {
+      var interfaces = popTypedList2<NamedType>(interfacesCount);
+      push(ast.implementsClause(implementsKeyword, interfaces));
+    } else {
+      push(NullValue.IdentifierList);
+    }
+  }
+
   @override
   void handleImportPrefix(Token? deferredKeyword, Token? asKeyword) {
     assert(optionalOrNull('deferred', deferredKeyword));
@@ -3404,6 +3511,14 @@ class AstBuilder extends StackListener {
     }
   }
 
+  @override
+  void handleNoTypeNameInConstructorReference(Token token) {
+    debugEvent("NoTypeNameInConstructorReference");
+    assert(enumDeclaration != null);
+
+    push(ast.simpleIdentifier(enumDeclaration!.name.token));
+  }
+
   @override
   void handleNoVariableInitializer(Token token) {
     debugEvent("NoVariableInitializer");

pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart

@@ -467,6 +467,7 @@ class AstTestFactory {
           name,
           TokenFactory.tokenFromType(TokenType.OPEN_CURLY_BRACKET),
           constants,
+          [],
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
 
   static EnumDeclarationImpl enumDeclaration2(

pkg/analyzer/test/generated/parser_fasta_listener.dart

@@ -732,9 +732,56 @@ class ForwardingTestListener extends ForwardingListener {
   }
 
   @override
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
     end('Enum');
-    super.endEnum(enumKeyword, leftBrace, count);
+    super.endEnum(enumKeyword, leftBrace, memberCount);
+  }
+
+  @override
+  void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    end('Method');
+    super.endEnumConstructor(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken);
+  }
+
+  @override
+  void endEnumFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    end('FactoryMethod');
+    super.endEnumFactoryMethod(beginToken, factoryKeyword, endToken);
+  }
+
+  @override
+  void endEnumFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    expectIn('Member');
+    super.endEnumFields(
+        abstractToken,
+        externalToken,
+        staticToken,
+        covariantToken,
+        lateToken,
+        varFinalOrConst,
+        count,
+        beginToken,
+        endToken);
+  }
+
+  @override
+  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    end('Method');
+    super.endEnumMethod(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken);
   }
 
   @override
@@ -1283,25 +1330,54 @@ class ForwardingTestListener extends ForwardingListener {
     listener?.handleClassHeader(begin, classKeyword, nativeToken);
   }
 
-  @override
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
-    expectInOneOf(['ClassDeclaration', 'MixinDeclaration']);
-    listener?.handleClassOrMixinImplements(implementsKeyword, interfacesCount);
-  }
-
   @override
   void handleDottedName(int count, Token firstIdentifier) {
     expectIn('ConditionalUri');
     super.handleDottedName(count, firstIdentifier);
   }
 
+  @override
+  void handleEnumElement(Token beginToken) {
+    expectIn('Enum');
+    super.handleEnumElement(beginToken);
+  }
+
+  @override
+  void handleEnumElements(Token elementsEndToken, int elementsCount) {
+    expectIn('Enum');
+    super.handleEnumElements(elementsEndToken, elementsCount);
+  }
+
+  @override
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    expectIn('Enum');
+    super.handleEnumHeader(enumKeyword, leftBrace);
+  }
+
+  @override
+  void handleEnumNoWithClause() {
+    expectIn('Enum');
+    super.handleEnumNoWithClause();
+  }
+
+  @override
+  void handleEnumWithClause(Token withKeyword) {
+    expectIn('Enum');
+    super.handleEnumWithClause(withKeyword);
+  }
+
   @override
   void handleIdentifierList(int count) {
     expectInOneOf(['Hide', 'Show']);
     super.handleIdentifierList(count);
   }
 
+  @override
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
+    expectInOneOf(['ClassDeclaration', 'MixinDeclaration', 'Enum']);
+    listener?.handleImplements(implementsKeyword, interfacesCount);
+  }
+
   @override
   void handleImportPrefix(Token? deferredKeyword, Token? asKeyword) {
     // This event normally happens within "Import",
@@ -1346,6 +1422,12 @@ class ForwardingTestListener extends ForwardingListener {
     listener?.handleNativeFunctionBodySkipped(nativeToken, semicolon);
   }
 
+  @override
+  void handleNoTypeNameInConstructorReference(Token token) {
+    expectIn('Enum');
+    super.handleNoTypeNameInConstructorReference(token);
+  }
+
   @override
   void handleRecoverClassHeader() {
     expectIn('ClassDeclaration');

pkg/analyzer/tool/summary/mini_ast.dart

@@ -285,16 +285,14 @@ class MiniAstBuilder extends StackListener {
   }
 
   @override
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
+  void endConstructorReference(Token start, Token? periodBeforeName,
+      Token endToken, ConstructorReferenceContext constructorReferenceContext) {
+    debugEvent("ConstructorReference");
+  }
+
+  @override
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
     debugEvent("Enum");
-    var constants =
-        List<EnumConstantDeclaration?>.filled(count, null, growable: true);
-    popList(count, constants);
-    var name = pop() as String;
-    var metadata = popTypedList<Annotation>();
-    var comment = pop() as Comment?;
-    compilationUnit.declarations.add(EnumDeclaration(
-        comment, metadata, name, constants.whereNotNull().toList()));
   }
 
   @override
@@ -421,6 +419,37 @@ class MiniAstBuilder extends StackListener {
     debugEvent("ClassWithClause");
   }
 
+  @override
+  void handleEnumElement(Token beginToken) {
+    debugEvent("EnumElement");
+    pop(); // Arguments.
+    pop(); // Type arguments.
+  }
+
+  @override
+  void handleEnumElements(Token endToken, int count) {
+    debugEvent("EnumElements");
+    var constants =
+        List<EnumConstantDeclaration?>.filled(count, null, growable: true);
+    popList(count, constants);
+    pop(); // Type variables.
+    var name = pop() as String;
+    var metadata = popTypedList<Annotation>();
+    var comment = pop() as Comment?;
+    compilationUnit.declarations.add(EnumDeclaration(
+        comment, metadata, name, constants.whereNotNull().toList()));
+  }
+
+  @override
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    debugEvent("EnumHeader");
+  }
+
+  @override
+  void handleEnumNoWithClause() {
+    debugEvent("NoEnumWithClause");
+  }
+
   @override
   void handleFormalParameterWithoutValue(Token token) {
     debugEvent("FormalParameterWithoutValue");
@@ -539,6 +568,11 @@ class MiniAstBuilder extends StackListener {
     reportNonNullAssertExpressionNotEnabled(bang);
   }
 
+  @override
+  void handleNoTypeNameInConstructorReference(Token token) {
+    debugEvent("NoTypeNameInConstructorReference");
+  }
+
   @override
   void handleQualified(Token period) {
     debugEvent("Qualified");

pkg/front_end/lib/src/fasta/builder/enum_builder.dart

@@ -120,7 +120,8 @@ class EnumBuilder extends SourceClassBuilder {
       int startCharOffset,
       int charOffset,
       int charEndOffset,
-      IndexedClass? referencesFromIndexed) {
+      IndexedClass? referencesFromIndexed,
+      Scope scope) {
     assert(enumConstantInfos == null || enumConstantInfos.isNotEmpty);
 
     Uri fileUri = parent.fileUri;
@@ -170,6 +171,7 @@ class EnumBuilder extends SourceClassBuilder {
         reference: referencesFromIndexed?.cls.reference,
         fileUri: fileUri);
     Map<String, MemberBuilder> members = <String, MemberBuilder>{};
+    Map<String, MemberBuilder> setters = <String, MemberBuilder>{};
     Map<String, MemberBuilder> constructors = <String, MemberBuilder>{};
     NamedTypeBuilder selfType = new NamedTypeBuilder(
         name,
@@ -357,11 +359,18 @@ class EnumBuilder extends SourceClassBuilder {
     }
     final int startCharOffsetComputed =
         metadata == null ? startCharOffset : metadata.first.charOffset;
+    scope.forEachLocalMember((name, member) {
+      members[name] = member as MemberBuilder;
+    });
+    scope.forEachLocalSetter((name, member) {
+      setters[name] = member;
+    });
     EnumBuilder enumBuilder = new EnumBuilder.internal(
         metadata,
         name,
         new Scope(
             local: members,
+            setters: setters,
             parent: parent.scope,
             debugName: "enum $name",
             isModifiable: false),

pkg/front_end/lib/src/fasta/source/diet_listener.dart

@@ -175,6 +175,11 @@ class DietListener extends StackListenerImpl {
     debugEvent("NoTypeArguments");
   }
 
+  @override
+  void handleNoTypeNameInConstructorReference(Token token) {
+    debugEvent("NoTypeNameInConstructorReference");
+  }
+
   @override
   void handleNoConstructorReferenceContinuationAfterTypeArguments(Token token) {
     debugEvent("NoConstructorReferenceContinuationAfterTypeArguments");
@@ -211,11 +216,26 @@ class DietListener extends StackListenerImpl {
     debugEvent("ClassNoWithClause");
   }
 
+  @override
+  void handleEnumWithClause(Token withKeyword) {
+    debugEvent("EnumWithClause");
+  }
+
+  @override
+  void handleEnumNoWithClause() {
+    debugEvent("EnumNoWithClause");
+  }
+
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     debugEvent("TypeArguments");
   }
 
+  @override
+  void endArguments(int count, Token beginToken, Token endToken) {
+    debugEvent("Arguments");
+  }
+
   @override
   void handleInvalidTypeArguments(Token token) {
     debugEvent("InvalidTypeArguments");
@@ -939,12 +959,103 @@ class DietListener extends StackListenerImpl {
   }
 
   @override
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
+  void beginEnum(Token enumKeyword) {
+    assert(checkState(enumKeyword, [ValueKinds.NameOrParserRecovery]));
+    debugEvent("Enum");
+    Object? name = pop();
+
+    assert(currentDeclaration == null);
+    assert(memberScope == libraryBuilder.scope);
+
+    if (name is ParserRecovery) {
+      currentClassIsParserRecovery = true;
+      return;
+    }
+
+    currentDeclaration =
+        lookupBuilder(enumKeyword, null, name as String) as DeclarationBuilder;
+    memberScope = currentDeclaration!.scope;
+  }
+
+  @override
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
     debugEvent("Enum");
-    const FixedNullableList<Object>().pop(stack, count * 2);
-    pop(); // Name.
-    pop(); // Annotations begin token.
     checkEmpty(enumKeyword.charOffset);
+    currentDeclaration = null;
+    memberScope = libraryBuilder.scope;
+  }
+
+  @override
+  void handleEnumElement(Token beginKeyword) {
+    debugEvent("EnumElement");
+  }
+
+  @override
+  void handleEnumElements(Token elementsEndToken, int elementsCount) {
+    debugEvent("EnumElements");
+    const FixedNullableList<Object>().pop(stack, elementsCount * 2);
+    pop(); // Annotations begin token.
+    checkEmpty(elementsEndToken.charOffset);
+  }
+
+  @override
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    debugEvent("EnumHeader");
+  }
+
+  @override
+  void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    // TODO(chloestefantsova): Call endClassConstructor instead.
+    debugEvent("EnumConstructor");
+    pop(); // bodyToken
+    pop(); // name
+    pop(); // metadata
+    checkEmpty(beginToken.charOffset);
+    // Skip the declaration. An error as already been produced by the parser.
+  }
+
+  @override
+  void endEnumFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    // TODO(chloestefantsova): Call endClassFactoryMethod instead.
+    debugEvent("EnumFactoryMethod");
+    pop(); // bodyToken
+    pop(); // name
+    pop(); // metadata
+    checkEmpty(beginToken.charOffset);
+    // Skip the declaration. An error as already been produced by the parser.
+  }
+
+  @override
+  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    // TODO(chloestefantsova): Call endClassMethod instead.
+    debugEvent("EnumMethod");
+    pop(); // bodyToken
+    pop(); // name
+    pop(); // metadata
+    checkEmpty(beginToken.charOffset);
+    // Skip the declaration. An error as already been produced by the parser.
+  }
+
+  @override
+  void endEnumFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    // TODO(chloestefantsova): Call endClassFields instead.
+    debugEvent("EnumFields");
+    const FixedNullableList<String>().pop(stack, count); // names
+    pop(); // metadata
+    checkEmpty(beginToken.charOffset);
+    // Skip the declaration. An error as already been produced by the parser.
   }
 
   @override

pkg/front_end/lib/src/fasta/source/outline_builder.dart

@@ -309,6 +309,33 @@ enum DeclarationContext {
   /// This includes type of the declaration but excludes annotations on the
   /// field declaration itself, which are seen in the [ExtensionBody] context.
   ExtensionStaticField,
+
+  /// In a generative constructor declaration inside an enum declaration.
+  EnumConstructor,
+
+  /// In a static method declaration inside an enum declaration.
+  EnumStaticMethod,
+
+  /// In a static field declaration inside an enum declaration.
+  EnumStaticField,
+
+  /// In an instance method declaration inside an enum declaration.
+  EnumInstanceMethod,
+
+  /// In an instance field declaration inside an enum declaration.
+  EnumInstanceField,
+
+  /// In a factory constructor declaration inside an enum declaration. This
+  /// is an error case.
+  ///
+  /// This excludes annotations on the constructor declaration itself, which
+  /// are seen in the [EnumBody] context.
+  EnumFactory,
+
+  /// In an enum declaration body.
+  ///
+  /// This includes annotations on extension member declarations.
+  EnumBody,
 }
 
 extension on DeclarationContext {
@@ -318,7 +345,6 @@ extension on DeclarationContext {
       case DeclarationContext.Typedef:
       case DeclarationContext.TopLevelMethod:
       case DeclarationContext.TopLevelField:
-      case DeclarationContext.Enum:
         return InstanceTypeVariableAccessState.Unexpected;
       case DeclarationContext.ClassOrMixinOrNamedMixinApplication:
       case DeclarationContext.NamedMixinApplication:
@@ -327,6 +353,10 @@ extension on DeclarationContext {
       case DeclarationContext.ClassFactory:
       case DeclarationContext.ClassInstanceMethod:
       case DeclarationContext.ClassInstanceField:
+      case DeclarationContext.Enum:
+      case DeclarationContext.EnumConstructor:
+      case DeclarationContext.EnumInstanceField:
+      case DeclarationContext.EnumInstanceMethod:
       case DeclarationContext.Mixin:
       case DeclarationContext.MixinInstanceMethod:
       case DeclarationContext.MixinInstanceField:
@@ -337,6 +367,9 @@ extension on DeclarationContext {
       case DeclarationContext.ClassBody:
       case DeclarationContext.ClassStaticMethod:
       case DeclarationContext.ClassStaticField:
+      case DeclarationContext.EnumStaticField:
+      case DeclarationContext.EnumStaticMethod:
+      case DeclarationContext.EnumBody:
       case DeclarationContext.MixinBody:
       case DeclarationContext.MixinStaticMethod:
       case DeclarationContext.MixinStaticField:
@@ -349,6 +382,7 @@ extension on DeclarationContext {
       case DeclarationContext.ExtensionConstructor:
       case DeclarationContext.ExtensionFactory:
       case DeclarationContext.ExtensionInstanceField:
+      case DeclarationContext.EnumFactory:
         return InstanceTypeVariableAccessState.Invalid;
     }
   }
@@ -824,6 +858,9 @@ class OutlineBuilder extends StackListenerImpl {
       case DeclarationKind.Extension:
         declarationContext = DeclarationContext.ExtensionBody;
         break;
+      case DeclarationKind.Enum:
+        declarationContext = DeclarationContext.Enum;
+        break;
     }
     pushDeclarationContext(declarationContext);
     if (kind == DeclarationKind.Extension) {
@@ -876,12 +913,21 @@ class OutlineBuilder extends StackListenerImpl {
   }
 
   @override
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
-    debugEvent("ClassOrMixinImplements");
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
+    debugEvent("Implements");
     push(const FixedNullableList<TypeBuilder>()
             .popNonNullable(stack, interfacesCount, dummyTypeBuilder) ??
         NullValue.TypeBuilderList);
+
+    if (!libraryBuilder.enableEnhancedEnumsInLibrary &&
+        implementsKeyword != null &&
+        declarationContext == DeclarationContext.Enum) {
+      addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
+          implementsKeyword.charOffset,
+          -1);
+    }
   }
 
   @override
@@ -1457,6 +1503,14 @@ class OutlineBuilder extends StackListenerImpl {
           declarationContext = DeclarationContext.ExtensionInstanceMethod;
         }
         break;
+      case DeclarationKind.Enum:
+        if (inConstructor) {
+          declarationContext = DeclarationContext.EnumConstructor;
+        } else if (staticToken != null) {
+          declarationContext = DeclarationContext.EnumStaticMethod;
+        } else {
+          declarationContext = DeclarationContext.EnumInstanceMethod;
+        }
     }
     pushDeclarationContext(declarationContext);
 
@@ -1909,6 +1963,12 @@ class OutlineBuilder extends StackListenerImpl {
         NullValue.TypeArguments);
   }
 
+  @override
+  void endArguments(int count, Token beginToken, Token endToken) {
+    debugEvent("Arguments");
+    push(NullValue.Arguments);
+  }
+
   @override
   void handleInvalidTypeArguments(Token token) {
     debugEvent("InvalidTypeArguments");
@@ -1958,12 +2018,31 @@ class OutlineBuilder extends StackListenerImpl {
         new ParserRecovery(-1));
   }
 
+  @override
+  void handleNoArguments(Token token) {
+    debugEvent("NoArguments");
+    push(NullValue.Arguments);
+  }
+
   @override
   void handleNoTypeVariables(Token token) {
     super.handleNoTypeVariables(token);
     inConstructorName = false;
   }
 
+  @override
+  void handleNoTypeArguments(Token token) {
+    debugEvent("NoTypeArguments");
+    push(NullValue.TypeArguments);
+  }
+
+  @override
+  void handleNoTypeNameInConstructorReference(Token token) {
+    debugEvent("NoTypeNameInConstructorReference");
+    push(NullValue.Name);
+    push(token.charOffset);
+  }
+
   @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
@@ -2168,23 +2247,70 @@ class OutlineBuilder extends StackListenerImpl {
 
   @override
   void beginEnum(Token enumKeyword) {
+    assert(checkState(
+        enumKeyword, [ValueKinds.Integer, ValueKinds.NameOrParserRecovery]));
+    int offset = pop() as int;
+    Object? name = pop();
+    push(name);
+    push(offset);
+
+    String declarationName;
+    if (name is String) {
+      declarationName = name;
+    } else {
+      declarationName = '#enum';
+    }
     pushDeclarationContext(DeclarationContext.Enum);
+    libraryBuilder.beginNestedDeclaration(
+        TypeParameterScopeKind.enumDeclaration, declarationName);
   }
 
   @override
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
-    debugEvent("Enum");
+  void handleEnumElement(Token beginToken) {
+    debugEvent("EnumElements");
+    pop(); // arguments.
+    pop(); // constructor reference.
+    // Keep on the stack the EnumConstantInfo created in handleIdentifier.
+  }
+
+  @override
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    debugEvent("EnumHeader");
+    push(enumKeyword.charOffset); // start char offset.
+    push(leftBrace.endGroup!.charOffset); // end char offset.
+  }
+
+  @override
+  void handleEnumElements(Token elementsEndToken, int elementsCount) {
+    debugEvent("EnumElements");
     List<EnumConstantInfo?>? enumConstantInfos =
-        const FixedNullableList<EnumConstantInfo>().pop(stack, count);
+        const FixedNullableList<EnumConstantInfo>().pop(stack, elementsCount);
+    int endCharOffset = popCharOffset();
+    int startCharOffset = popCharOffset();
+    pop() as List<TypeBuilder>?; // interfaces.
+    pop() as List<TypeBuilder>?; // mixins.
+    List<TypeVariableBuilder>? typeVariables =
+        pop() as List<TypeVariableBuilder>?;
     int charOffset = popCharOffset(); // identifier char offset.
-    int startCharOffset = enumKeyword.charOffset;
     Object? name = pop();
     List<MetadataBuilder>? metadata = pop() as List<MetadataBuilder>?;
-    checkEmpty(enumKeyword.charOffset);
+    checkEmpty(startCharOffset);
+
     if (name is! ParserRecovery) {
       libraryBuilder.addEnum(metadata, name as String, enumConstantInfos,
-          startCharOffset, charOffset, leftBrace.endGroup!.charOffset);
+          startCharOffset, charOffset, endCharOffset);
+    } else {
+      libraryBuilder
+          .endNestedDeclaration(
+              TypeParameterScopeKind.enumDeclaration, "<syntax-error>")
+          .resolveNamedTypes(typeVariables, libraryBuilder);
     }
+  }
+
+  @override
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
+    debugEvent("Enum");
+    checkEmpty(enumKeyword.charOffset);
     popDeclarationContext(DeclarationContext.Enum);
   }
 
@@ -2413,6 +2539,12 @@ class OutlineBuilder extends StackListenerImpl {
           declarationContext = DeclarationContext.ExtensionInstanceField;
         }
         break;
+      case DeclarationKind.Enum:
+        if (staticToken != null) {
+          declarationContext = DeclarationContext.EnumStaticMethod;
+        } else {
+          declarationContext = DeclarationContext.EnumInstanceMethod;
+        }
     }
     pushDeclarationContext(declarationContext);
   }
@@ -2588,6 +2720,15 @@ class OutlineBuilder extends StackListenerImpl {
   void endTypeVariables(Token beginToken, Token endToken) {
     debugEvent("endTypeVariables");
 
+    if (!libraryBuilder.enableEnhancedEnumsInLibrary &&
+        declarationContext == DeclarationContext.Enum) {
+      addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
+          beginToken.charOffset,
+          -1);
+    }
+
     // Peek to leave type parameters on top of stack.
     List<TypeVariableBuilder>? typeParameters =
         peek() as List<TypeVariableBuilder>?;
@@ -2681,12 +2822,44 @@ class OutlineBuilder extends StackListenerImpl {
     String? suffix = popIfNotNull(periodBeforeName) as String?;
     List<TypeBuilder>? typeArguments = pop() as List<TypeBuilder>?;
     int charOffset = popCharOffset();
-    Object name = pop()!;
+    Object? name = pop();
     if (name is ParserRecovery) {
       push(name);
-    } else {
+    } else if (name != null) {
       push(libraryBuilder.addConstructorReference(
           name, typeArguments, suffix, charOffset));
+    } else {
+      assert(name == null);
+      // At the moment, the name of the type in a constructor reference can be
+      // omitted only within an enum element declaration.
+      if (libraryBuilder.currentTypeParameterScopeBuilder.kind ==
+          TypeParameterScopeKind.enumDeclaration) {
+        if (libraryBuilder.enableEnhancedEnumsInLibrary) {
+          push(libraryBuilder.addConstructorReference(
+              libraryBuilder.currentTypeParameterScopeBuilder.name,
+              typeArguments,
+              suffix,
+              charOffset));
+        } else {
+          // For entries that consist of their name only, all of the elements
+          // of the constructor reference should be null.
+          if (typeArguments != null || suffix != null) {
+            addProblem(
+                templateExperimentNotEnabled.withArguments(
+                    'enhanced-enums',
+                    libraryBuilder.enableEnhancedEnumsVersionInLibrary
+                        .toText()),
+                charOffset,
+                -1);
+          }
+          push(NullValue.ConstructorReference);
+        }
+      } else {
+        internalProblem(
+            messageInternalProblemOmittedTypeNameInConstructorReference,
+            charOffset,
+            uri);
+      }
     }
   }
 
@@ -2706,6 +2879,9 @@ class OutlineBuilder extends StackListenerImpl {
       case DeclarationKind.Extension:
         declarationContext = DeclarationContext.ExtensionFactory;
         break;
+      case DeclarationKind.Enum:
+        declarationContext = DeclarationContext.EnumFactory;
+        break;
     }
 
     pushDeclarationContext(declarationContext);
@@ -2779,6 +2955,150 @@ class OutlineBuilder extends StackListenerImpl {
     _endFactoryMethod(beginToken, factoryKeyword, endToken);
   }
 
+  @override
+  void endEnumFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    // TODO(cstefantsova): Call endClassFactoryMethod instead.
+    debugEvent("EnumFactoryMethod");
+    MethodBody bodyKind = pop() as MethodBody;
+    if (bodyKind == MethodBody.RedirectingFactoryBody) {
+      pop(); // reference
+    }
+    pop(); // async marker
+    pop(); // formals
+    popCharOffset(); // formals char offset
+    pop(); // type variables
+    popCharOffset(); // char offset
+    pop(); // name
+    pop(); // modifiers
+    pop(); // metadata
+    checkEmpty(beginToken.charOffset);
+    popDeclarationContext();
+    // TODO(cstefantsova): Use actual type parameters.
+    libraryBuilder
+        .endNestedDeclaration(
+            TypeParameterScopeKind.factoryMethod, "#factory_method")
+        .resolveNamedTypes([], libraryBuilder);
+    // Skip the declaration. An error as already been produced by the parser.
+
+    if (libraryBuilder.enableEnhancedEnumsInLibrary) {
+      addProblem(messageEnumDeclaresFactory, beginToken.charOffset, -1);
+    } else {
+      addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
+          beginToken.charOffset,
+          -1);
+    }
+  }
+
+  @override
+  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    // TODO(cstefantsova): Call endClassMethod instead.
+    debugEvent("EnumMethod");
+    MethodBody bodyKind = pop() as MethodBody;
+    if (bodyKind == MethodBody.RedirectingFactoryBody) {
+      pop(); // reference
+    }
+    pop(); // async marker
+    pop(); // formals
+    popCharOffset(); // formals char offset
+    pop(); // type variables
+    popCharOffset(); // char offset
+    pop(); // name
+    pop(); // return type
+    int modifiers = Modifier.toMask(pop() as List<Modifier>?);
+    popCharOffset(); // final or const offset
+    pop(); // metadata
+    checkEmpty(beginToken.charOffset);
+    popDeclarationContext();
+    TypeParameterScopeKind scopeKind;
+    if ((modifiers & staticMask) != 0) {
+      scopeKind = TypeParameterScopeKind.staticMethod;
+    } else {
+      scopeKind = TypeParameterScopeKind.instanceMethod;
+    }
+    // TODO(cstefantsova): Use actual type parameters.
+    libraryBuilder
+        .endNestedDeclaration(scopeKind, "#method")
+        .resolveNamedTypes([], libraryBuilder);
+    // Skip the declaration. An error as already been produced by the parser.
+
+    if (!libraryBuilder.enableEnhancedEnumsInLibrary) {
+      addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
+          beginToken.charOffset,
+          -1);
+    }
+  }
+
+  @override
+  void endEnumFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    // TODO(cstefantsova): Call endClassFields instead.
+    debugEvent("EnumFields");
+    popFieldInfos(count); // field infos
+    pop(); // type
+    pop(); // metadata
+    checkEmpty(beginToken.charOffset);
+    popDeclarationContext();
+    // Skip the declaration. An error as already been produced by the parser.
+
+    if (!libraryBuilder.enableEnhancedEnumsInLibrary) {
+      addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
+          beginToken.charOffset,
+          -1);
+    }
+  }
+
+  @override
+  void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    // TODO(cstefantsova): Call endClassConstructor instead.
+    debugEvent("EnumMethod");
+    MethodBody bodyKind = pop() as MethodBody;
+    if (bodyKind == MethodBody.RedirectingFactoryBody) {
+      pop(); // reference
+    }
+    pop(); // async marker
+    pop(); // formals
+    popCharOffset(); // formals char offset
+    pop(); // type variables
+    popCharOffset(); // char offset
+    pop(); // name
+    pop(); // return type
+    pop(); // modifiers
+    popCharOffset(); // final or const offset
+    pop(); // metadata
+    checkEmpty(beginToken.charOffset);
+    popDeclarationContext();
+    // TODO(cstefantsova): Use actual type parameters.
+    libraryBuilder
+        .endNestedDeclaration(TypeParameterScopeKind.instanceMethod, "#method")
+        .resolveNamedTypes([], libraryBuilder);
+    // Skip the declaration. An error as already been produced by the parser.
+
+    if (!libraryBuilder.enableEnhancedEnumsInLibrary) {
+      addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
+          beginToken.charOffset,
+          -1);
+    }
+  }
+
   @override
   void endRedirectingFactoryBody(Token beginToken, Token endToken) {
     debugEvent("RedirectingFactoryBody");
@@ -2868,6 +3188,33 @@ class OutlineBuilder extends StackListenerImpl {
     debugEvent("ClassNoWithClause");
   }
 
+  @override
+  void handleEnumWithClause(Token withKeyword) {
+    debugEvent("EnumWithClause");
+
+    if (!libraryBuilder.enableEnhancedEnumsInLibrary) {
+      addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
+          withKeyword.charOffset,
+          -1);
+    }
+
+    Object? mixins = pop();
+    if (mixins is ParserRecovery) {
+      push(new ParserRecovery(withKeyword.charOffset));
+    } else {
+      // TODO(cstefantsova): Handle enum mixins here.
+      push(mixins);
+    }
+  }
+
+  @override
+  void handleEnumNoWithClause() {
+    debugEvent("EnumNoWithClause");
+    push(NullValue.TypeBuilderList);
+  }
+
   @override
   void handleClassHeader(Token begin, Token classKeyword, Token? nativeToken) {
     debugEvent("ClassHeader");

pkg/front_end/lib/src/fasta/source/source_library_builder.dart

@@ -319,10 +319,12 @@ class SourceLibraryBuilder extends LibraryBuilderImpl {
   Version? _enableExtensionTypesVersionInLibrary;
   Version? _enableNamedArgumentsAnywhereVersionInLibrary;
   Version? _enableSuperParametersVersionInLibrary;
+  Version? _enableEnhancedEnumsVersionInLibrary;
   bool? _enableTripleShiftInLibrary;
   bool? _enableExtensionMethodsInLibrary;
   bool? _enableGenericMetadataInLibrary;
   bool? _enableExtensionTypesInLibrary;
+  bool? _enableEnhancedEnumsInLibrary;
   bool? _enableConstructorTearOffsInLibrary;
   bool? _enableNamedArgumentsAnywhereInLibrary;
   bool? _enableSuperParametersInLibrary;
@@ -424,6 +426,17 @@ class SourceLibraryBuilder extends LibraryBuilderImpl {
           .getExperimentEnabledVersionInLibrary(
               ExperimentalFlag.superParameters, _packageUri ?? importUri);
 
+  bool get enableEnhancedEnumsInLibrary => _enableEnhancedEnumsInLibrary ??=
+      loader.target.isExperimentEnabledInLibraryByVersion(
+          ExperimentalFlag.enhancedEnums,
+          _packageUri ?? importUri,
+          languageVersion.version);
+
+  Version get enableEnhancedEnumsVersionInLibrary =>
+      _enableEnhancedEnumsVersionInLibrary ??= loader.target
+          .getExperimentEnabledVersionInLibrary(
+              ExperimentalFlag.enhancedEnums, _packageUri ?? importUri);
+
   void _updateLibraryNNBDSettings() {
     library.isNonNullableByDefault = isNonNullableByDefault;
     switch (loader.nnbdMode) {
@@ -2677,6 +2690,11 @@ class SourceLibraryBuilder extends LibraryBuilderImpl {
       referencesFromIndexedClass =
           referencesFromIndexed!.lookupIndexedClass(name);
     }
+    // Nested declaration began in `OutlineBuilder.beginEnum`.
+    // TODO(cstefantsova): Use actual type variables here.
+    TypeParameterScopeBuilder declaration =
+        endNestedDeclaration(TypeParameterScopeKind.enumDeclaration, name)
+          ..resolveNamedTypes([], this);
     EnumBuilder builder = new EnumBuilder(
         metadata,
         name,
@@ -2685,7 +2703,13 @@ class SourceLibraryBuilder extends LibraryBuilderImpl {
         startCharOffset,
         charOffset,
         charEndOffset,
-        referencesFromIndexedClass);
+        referencesFromIndexedClass,
+        new Scope(
+            local: declaration.members!,
+            setters: declaration.setters!,
+            parent: scope.withTypeVariables(<TypeVariableBuilder>[]),
+            debugName: "enum $name",
+            isModifiable: false));
     addBuilder(name, builder, charOffset,
         getterReference: referencesFromIndexedClass?.cls.reference);
   }
@@ -4586,6 +4610,7 @@ enum TypeParameterScopeKind {
   topLevelMethod,
   factoryMethod,
   functionType,
+  enumDeclaration,
 }
 
 /// A builder object preparing for building declarations that can introduce type

pkg/front_end/lib/src/fasta/util/parser_ast.dart

@@ -867,9 +867,9 @@ extension ClassDeclarationExtension on ClassDeclarationEnd {
     throw "Not found.";
   }
 
-  ClassOrMixinImplementsHandle getClassImplements() {
+  ImplementsHandle getClassImplements() {
     for (ParserAstNode child in children!) {
-      if (child is ClassOrMixinImplementsHandle) {
+      if (child is ImplementsHandle) {
         return child;
       }
     }
@@ -1512,24 +1512,30 @@ class ParserASTListener extends AbstractParserAstListener {
                 end == "ExtensionConstructor" ||
                 end == "ExtensionMethod" ||
                 end == "MixinConstructor" ||
-                end == "MixinMethod")) {
-          // beginMethod is ended by one of endClassConstructor, endClassMethod,
-          // endExtensionMethod, endMixinConstructor or endMixinMethod.
+                end == "MixinMethod" ||
+                end == "EnumConstructor" ||
+                end == "EnumMethod")) {
+          // beginMethod is ended by one of endClassConstructor,
+          // endClassMethod, endExtensionMethod, endMixinConstructor,
+          // endMixinMethod, endEnumMethod or endEnumConstructor.
         } else if (begin == "Fields" &&
             (end == "TopLevelFields" ||
                 end == "ClassFields" ||
                 end == "MixinFields" ||
-                end == "ExtensionFields")) {
-          // beginFields is ended by one of endTopLevelFields, endMixinFields or
-          // endExtensionFields.
+                end == "ExtensionFields" ||
+                end == "EnumFields")) {
+          // beginFields is ended by one of endTopLevelFields, endMixinFields,
+          // endEnumFields or endExtensionFields.
         } else if (begin == "ForStatement" && end == "ForIn") {
           // beginForStatement is ended by either endForStatement or endForIn.
         } else if (begin == "FactoryMethod" &&
             (end == "ClassFactoryMethod" ||
                 end == "MixinFactoryMethod" ||
-                end == "ExtensionFactoryMethod")) {
+                end == "ExtensionFactoryMethod" ||
+                end == "EnumFactoryMethod")) {
           // beginFactoryMethod is ended by either endClassFactoryMethod,
-          // endMixinFactoryMethod or endExtensionFactoryMethod.
+          // endMixinFactoryMethod, endExtensionFactoryMethod, or
+          // endEnumFactoryMethod.
         } else if (begin == "ForControlFlow" && (end == "ForInControlFlow")) {
           // beginForControlFlow is ended by either endForControlFlow or
           // endForInControlFlow.

pkg/front_end/lib/src/fasta/util/parser_ast_helper.dart

@@ -179,12 +179,9 @@ abstract class AbstractParserAstListener implements Listener {
   }
 
   @override
-  void handleClassOrMixinImplements(
-      Token? implementsKeyword, int interfacesCount) {
-    ClassOrMixinImplementsHandle data = new ClassOrMixinImplementsHandle(
-        ParserAstType.HANDLE,
-        implementsKeyword: implementsKeyword,
-        interfacesCount: interfacesCount);
+  void handleImplements(Token? implementsKeyword, int interfacesCount) {
+    ImplementsHandle data = new ImplementsHandle(ParserAstType.HANDLE,
+        implementsKeyword: implementsKeyword, interfacesCount: interfacesCount);
     seen(data);
   }
 
@@ -411,9 +408,54 @@ abstract class AbstractParserAstListener implements Listener {
   }
 
   @override
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
+  void endEnum(Token enumKeyword, Token leftBrace, int memberCount) {
     EnumEnd data = new EnumEnd(ParserAstType.END,
-        enumKeyword: enumKeyword, leftBrace: leftBrace, count: count);
+        enumKeyword: enumKeyword,
+        leftBrace: leftBrace,
+        memberCount: memberCount);
+    seen(data);
+  }
+
+  @override
+  void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    EnumConstructorEnd data = new EnumConstructorEnd(ParserAstType.END,
+        getOrSet: getOrSet,
+        beginToken: beginToken,
+        beginParam: beginParam,
+        beginInitializers: beginInitializers,
+        endToken: endToken);
+    seen(data);
+  }
+
+  @override
+  void handleEnumElements(Token elementsEndToken, int elementsCount) {
+    EnumElementsHandle data = new EnumElementsHandle(ParserAstType.HANDLE,
+        elementsEndToken: elementsEndToken, elementsCount: elementsCount);
+    seen(data);
+  }
+
+  @override
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
+    EnumHeaderHandle data = new EnumHeaderHandle(ParserAstType.HANDLE,
+        enumKeyword: enumKeyword, leftBrace: leftBrace);
+    seen(data);
+  }
+
+  @override
+  void handleEnumElement(Token beginToken) {
+    EnumElementHandle data =
+        new EnumElementHandle(ParserAstType.HANDLE, beginToken: beginToken);
+    seen(data);
+  }
+
+  @override
+  void endEnumFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token endToken) {
+    EnumFactoryMethodEnd data = new EnumFactoryMethodEnd(ParserAstType.END,
+        beginToken: beginToken,
+        factoryKeyword: factoryKeyword,
+        endToken: endToken);
     seen(data);
   }
 
@@ -618,6 +660,42 @@ abstract class AbstractParserAstListener implements Listener {
     seen(data);
   }
 
+  @override
+  void endEnumFields(
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      int count,
+      Token beginToken,
+      Token endToken) {
+    EnumFieldsEnd data = new EnumFieldsEnd(ParserAstType.END,
+        abstractToken: abstractToken,
+        externalToken: externalToken,
+        staticToken: staticToken,
+        covariantToken: covariantToken,
+        lateToken: lateToken,
+        varFinalOrConst: varFinalOrConst,
+        count: count,
+        beginToken: beginToken,
+        endToken: endToken);
+    seen(data);
+  }
+
+  @override
+  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    EnumMethodEnd data = new EnumMethodEnd(ParserAstType.END,
+        getOrSet: getOrSet,
+        beginToken: beginToken,
+        beginParam: beginParam,
+        beginInitializers: beginInitializers,
+        endToken: endToken);
+    seen(data);
+  }
+
   @override
   void handleForInitializerEmptyStatement(Token token) {
     ForInitializerEmptyStatementHandle data =
@@ -823,6 +901,20 @@ abstract class AbstractParserAstListener implements Listener {
     seen(data);
   }
 
+  @override
+  void handleEnumWithClause(Token withKeyword) {
+    EnumWithClauseHandle data = new EnumWithClauseHandle(ParserAstType.HANDLE,
+        withKeyword: withKeyword);
+    seen(data);
+  }
+
+  @override
+  void handleEnumNoWithClause() {
+    EnumNoWithClauseHandle data =
+        new EnumNoWithClauseHandle(ParserAstType.HANDLE);
+    seen(data);
+  }
+
   @override
   void beginNamedMixinApplication(
       Token begin, Token? abstractToken, Token name) {
@@ -2187,6 +2279,14 @@ abstract class AbstractParserAstListener implements Listener {
     seen(data);
   }
 
+  @override
+  void handleNoTypeNameInConstructorReference(Token token) {
+    NoTypeNameInConstructorReferenceHandle data =
+        new NoTypeNameInConstructorReferenceHandle(ParserAstType.HANDLE,
+            token: token);
+    seen(data);
+  }
+
   @override
   void handleNoType(Token lastConsumed) {
     NoTypeHandle data =
@@ -2747,13 +2847,13 @@ class ClassExtendsHandle extends ParserAstNode {
       };
 }
 
-class ClassOrMixinImplementsHandle extends ParserAstNode {
+class ImplementsHandle extends ParserAstNode {
   final Token? implementsKeyword;
   final int interfacesCount;
 
-  ClassOrMixinImplementsHandle(ParserAstType type,
+  ImplementsHandle(ParserAstType type,
       {this.implementsKeyword, required this.interfacesCount})
-      : super("ClassOrMixinImplements", type);
+      : super("Implements", type);
 
   @override
   Map<String, Object?> get deprecatedArguments => {
@@ -3167,17 +3267,105 @@ class EnumBegin extends ParserAstNode {
 class EnumEnd extends ParserAstNode {
   final Token enumKeyword;
   final Token leftBrace;
-  final int count;
+  final int memberCount;
 
   EnumEnd(ParserAstType type,
-      {required this.enumKeyword, required this.leftBrace, required this.count})
+      {required this.enumKeyword,
+      required this.leftBrace,
+      required this.memberCount})
       : super("Enum", type);
 
   @override
   Map<String, Object?> get deprecatedArguments => {
         "enumKeyword": enumKeyword,
         "leftBrace": leftBrace,
-        "count": count,
+        "memberCount": memberCount,
+      };
+}
+
+class EnumConstructorEnd extends ParserAstNode {
+  final Token? getOrSet;
+  final Token beginToken;
+  final Token beginParam;
+  final Token? beginInitializers;
+  final Token endToken;
+
+  EnumConstructorEnd(ParserAstType type,
+      {this.getOrSet,
+      required this.beginToken,
+      required this.beginParam,
+      this.beginInitializers,
+      required this.endToken})
+      : super("EnumConstructor", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "getOrSet": getOrSet,
+        "beginToken": beginToken,
+        "beginParam": beginParam,
+        "beginInitializers": beginInitializers,
+        "endToken": endToken,
+      };
+}
+
+class EnumElementsHandle extends ParserAstNode {
+  final Token elementsEndToken;
+  final int elementsCount;
+
+  EnumElementsHandle(ParserAstType type,
+      {required this.elementsEndToken, required this.elementsCount})
+      : super("EnumElements", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "elementsEndToken": elementsEndToken,
+        "elementsCount": elementsCount,
+      };
+}
+
+class EnumHeaderHandle extends ParserAstNode {
+  final Token enumKeyword;
+  final Token leftBrace;
+
+  EnumHeaderHandle(ParserAstType type,
+      {required this.enumKeyword, required this.leftBrace})
+      : super("EnumHeader", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "enumKeyword": enumKeyword,
+        "leftBrace": leftBrace,
+      };
+}
+
+class EnumElementHandle extends ParserAstNode {
+  final Token beginToken;
+
+  EnumElementHandle(ParserAstType type, {required this.beginToken})
+      : super("EnumElement", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "beginToken": beginToken,
+      };
+}
+
+class EnumFactoryMethodEnd extends ParserAstNode {
+  final Token beginToken;
+  final Token factoryKeyword;
+  final Token endToken;
+
+  EnumFactoryMethodEnd(ParserAstType type,
+      {required this.beginToken,
+      required this.factoryKeyword,
+      required this.endToken})
+      : super("EnumFactoryMethod", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "beginToken": beginToken,
+        "factoryKeyword": factoryKeyword,
+        "endToken": endToken,
       };
 }
 
@@ -3536,6 +3724,68 @@ class ExtensionFieldsEnd extends ParserAstNode {
       };
 }
 
+class EnumFieldsEnd extends ParserAstNode {
+  final Token? abstractToken;
+  final Token? externalToken;
+  final Token? staticToken;
+  final Token? covariantToken;
+  final Token? lateToken;
+  final Token? varFinalOrConst;
+  final int count;
+  final Token beginToken;
+  final Token endToken;
+
+  EnumFieldsEnd(ParserAstType type,
+      {this.abstractToken,
+      this.externalToken,
+      this.staticToken,
+      this.covariantToken,
+      this.lateToken,
+      this.varFinalOrConst,
+      required this.count,
+      required this.beginToken,
+      required this.endToken})
+      : super("EnumFields", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "abstractToken": abstractToken,
+        "externalToken": externalToken,
+        "staticToken": staticToken,
+        "covariantToken": covariantToken,
+        "lateToken": lateToken,
+        "varFinalOrConst": varFinalOrConst,
+        "count": count,
+        "beginToken": beginToken,
+        "endToken": endToken,
+      };
+}
+
+class EnumMethodEnd extends ParserAstNode {
+  final Token? getOrSet;
+  final Token beginToken;
+  final Token beginParam;
+  final Token? beginInitializers;
+  final Token endToken;
+
+  EnumMethodEnd(ParserAstType type,
+      {this.getOrSet,
+      required this.beginToken,
+      required this.beginParam,
+      this.beginInitializers,
+      required this.endToken})
+      : super("EnumMethod", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "getOrSet": getOrSet,
+        "beginToken": beginToken,
+        "beginParam": beginParam,
+        "beginInitializers": beginInitializers,
+        "endToken": endToken,
+      };
+}
+
 class ForInitializerEmptyStatementHandle extends ParserAstNode {
   final Token token;
 
@@ -3909,6 +4159,25 @@ class ClassNoWithClauseHandle extends ParserAstNode {
   Map<String, Object?> get deprecatedArguments => {};
 }
 
+class EnumWithClauseHandle extends ParserAstNode {
+  final Token withKeyword;
+
+  EnumWithClauseHandle(ParserAstType type, {required this.withKeyword})
+      : super("EnumWithClause", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "withKeyword": withKeyword,
+      };
+}
+
+class EnumNoWithClauseHandle extends ParserAstNode {
+  EnumNoWithClauseHandle(ParserAstType type) : super("EnumNoWithClause", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {};
+}
+
 class NamedMixinApplicationBegin extends ParserAstNode {
   final Token begin;
   final Token? abstractToken;
@@ -6377,6 +6646,19 @@ class NoConstructorReferenceContinuationAfterTypeArgumentsHandle
       };
 }
 
+class NoTypeNameInConstructorReferenceHandle extends ParserAstNode {
+  final Token token;
+
+  NoTypeNameInConstructorReferenceHandle(ParserAstType type,
+      {required this.token})
+      : super("NoTypeNameInConstructorReference", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "token": token,
+      };
+}
+
 class NoTypeHandle extends ParserAstNode {
   final Token lastConsumed;
 

pkg/front_end/lib/src/fasta/util/textual_outline.dart

@@ -759,7 +759,7 @@ class TextualOutlineListener extends Listener {
   }
 
   @override
-  void endEnum(Token enumKeyword, Token leftBrace, int count) {
+  void handleEnumHeader(Token enumKeyword, Token leftBrace) {
     elementStartToChunk[enumKeyword] =
         new _EnumChunk(enumKeyword, leftBrace.endGroup!);
   }

pkg/front_end/messages.status

@@ -212,6 +212,8 @@ DuplicatedNamedArgument/example: Fail
 DuplicatedParameterName/example: Fail
 Encoding/analyzerCode: Fail
 EnumConstantSameNameAsEnclosing/example: Fail
+EnumDeclaresFactory/analyzerCode: Fail
+EnumDeclaresFactory/example: Fail
 EnumInstantiation/example: Fail
 EqualityCannotBeEqualityOperand/part_wrapped_script1: Fail
 EqualityCannotBeEqualityOperand/part_wrapped_script2: Fail
@@ -525,10 +527,6 @@ JsInteropExternalMemberNotJSAnnotated/analyzerCode: Fail # Web compiler specific
 JsInteropExternalMemberNotJSAnnotated/example: Fail # Web compiler specific
 JsInteropIndexNotSupported/analyzerCode: Fail # Web compiler specific
 JsInteropIndexNotSupported/example: Fail # Web compiler specific
-JsInteropStaticInteropWithInstanceMembers/analyzerCode: Fail # Web compiler specific
-JsInteropStaticInteropWithInstanceMembers/example: Fail # Web compiler specific
-JsInteropStaticInteropWithNonStaticSupertype/analyzerCode: Fail # Web compiler specific
-JsInteropStaticInteropWithNonStaticSupertype/example: Fail # Web compiler specific
 JsInteropJSClassExtendsDartClass/analyzerCode: Fail # Web compiler specific
 JsInteropJSClassExtendsDartClass/example: Fail # Web compiler specific
 JsInteropNamedParameters/analyzerCode: Fail # Web compiler specific
@@ -539,6 +537,10 @@ JsInteropNonExternalConstructor/analyzerCode: Fail # Web compiler specific
 JsInteropNonExternalConstructor/example: Fail # Web compiler specific
 JsInteropNonExternalMember/analyzerCode: Fail # Web compiler specific
 JsInteropNonExternalMember/example: Fail # Web compiler specific
+JsInteropStaticInteropWithInstanceMembers/analyzerCode: Fail # Web compiler specific
+JsInteropStaticInteropWithInstanceMembers/example: Fail # Web compiler specific
+JsInteropStaticInteropWithNonStaticSupertype/analyzerCode: Fail # Web compiler specific
+JsInteropStaticInteropWithNonStaticSupertype/example: Fail # Web compiler specific
 LanguageVersionInvalidInDotPackages/analyzerCode: Fail
 LanguageVersionMismatchInPart/analyzerCode: Fail
 LanguageVersionMismatchInPart/part_wrapped_script: Fail # Part in (now) part.

pkg/front_end/messages.yaml

@@ -2069,6 +2069,10 @@ InternalProblemUnsupportedNullability:
   problemMessage: "Unsupported nullability value '#string' on type '#type'."
   severity: INTERNAL_PROBLEM
 
+InternalProblemOmittedTypeNameInConstructorReference:
+  problemMessage: "Unsupported omission of the type name in a constructor reference outside of an enum element declaration."
+  severity: INTERNAL_PROBLEM
+
 IncrementalCompilerIllegalParameter:
   problemMessage: "Illegal parameter name '#string' found during expression compilation."
 
@@ -5436,3 +5440,7 @@ NewAsSelector:
   experiments: constructor-tearoffs
   script: |
     method(dynamic d) => d.new;
+
+EnumDeclaresFactory:
+  problemMessage: "Enums can't declare factory constructors."
+  correctionMessage: "Try removing the factory constructor declaration."

pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart

@@ -0,0 +1,8 @@
+enum E<X, Y> {
+  one<int, String>(),
+  two<double, num>(),
+  three<int, int>.named(42);
+
+  const E();
+  const E.named(int value);
+}

pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.expect

@@ -0,0 +1,122 @@
+beginCompilationUnit(enum)
+  beginMetadataStar(enum)
+  endMetadataStar(0)
+  beginUncategorizedTopLevelDeclaration(enum)
+    handleIdentifier(E, enumDeclaration)
+    beginEnum(enum)
+      beginTypeVariables(<)
+        beginMetadataStar(X)
+        endMetadataStar(0)
+        handleIdentifier(X, typeVariableDeclaration)
+        beginTypeVariable(X)
+          beginMetadataStar(Y)
+          endMetadataStar(0)
+          handleIdentifier(Y, typeVariableDeclaration)
+          beginTypeVariable(Y)
+            handleTypeVariablesDefined(Y, 2)
+            handleNoType(Y)
+          endTypeVariable(>, 1, null, null)
+          handleNoType(X)
+        endTypeVariable(,, 0, null, null)
+      endTypeVariables(<, >)
+      handleEnumNoWithClause()
+      handleImplements(null, 0)
+      handleEnumHeader(enum, {)
+      beginMetadataStar(one)
+      endMetadataStar(0)
+      handleIdentifier(one, enumValueDeclaration)
+      handleNoTypeNameInConstructorReference(<)
+      beginConstructorReference(one)
+        beginTypeArguments(<)
+          handleIdentifier(int, typeReference)
+          handleNoTypeArguments(,)
+          handleType(int, null)
+          handleIdentifier(String, typeReference)
+          handleNoTypeArguments(>)
+          handleType(String, null)
+        endTypeArguments(2, <, >)
+        handleNoConstructorReferenceContinuationAfterTypeArguments(()
+      endConstructorReference(one, null, (, ConstructorReferenceContext.Const)
+      beginArguments(()
+      endArguments(0, (, ))
+      handleEnumElement({)
+      beginMetadataStar(two)
+      endMetadataStar(0)
+      handleIdentifier(two, enumValueDeclaration)
+      handleNoTypeNameInConstructorReference(<)
+      beginConstructorReference(two)
+        beginTypeArguments(<)
+          handleIdentifier(double, typeReference)
+          handleNoTypeArguments(,)
+          handleType(double, null)
+          handleIdentifier(num, typeReference)
+          handleNoTypeArguments(>)
+          handleType(num, null)
+        endTypeArguments(2, <, >)
+        handleNoConstructorReferenceContinuationAfterTypeArguments(()
+      endConstructorReference(two, null, (, ConstructorReferenceContext.Const)
+      beginArguments(()
+      endArguments(0, (, ))
+      handleEnumElement(,)
+      beginMetadataStar(three)
+      endMetadataStar(0)
+      handleIdentifier(three, enumValueDeclaration)
+      handleNoTypeNameInConstructorReference(<)
+      beginConstructorReference(three)
+        beginTypeArguments(<)
+          handleIdentifier(int, typeReference)
+          handleNoTypeArguments(,)
+          handleType(int, null)
+          handleIdentifier(int, typeReference)
+          handleNoTypeArguments(>)
+          handleType(int, null)
+        endTypeArguments(2, <, >)
+        handleIdentifier(named, constructorReferenceContinuationAfterTypeArguments)
+      endConstructorReference(three, ., (, ConstructorReferenceContext.Const)
+      beginArguments(()
+        handleLiteralInt(42)
+      endArguments(1, (, ))
+      handleEnumElement(,)
+      handleEnumElements(;, 3)
+      beginMetadataStar(const)
+      endMetadataStar(0)
+      beginMember()
+        beginMethod(DeclarationKind.Enum, null, null, null, const, null, E)
+          handleNoType(const)
+          handleIdentifier(E, methodDeclaration)
+          handleNoTypeVariables(()
+          beginFormalParameters((, MemberKind.NonStaticMethod)
+          endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
+          handleNoInitializers()
+          handleAsyncModifier(null, null)
+          handleEmptyFunctionBody(;)
+        endEnumConstructor(null, const, (, null, ;)
+      endMember()
+      beginMetadataStar(const)
+      endMetadataStar(0)
+      beginMember()
+        beginMethod(DeclarationKind.Enum, null, null, null, const, null, E)
+          handleNoType(const)
+          handleIdentifier(E, methodDeclaration)
+          handleIdentifier(named, methodDeclarationContinuation)
+          handleQualified(.)
+          handleNoTypeVariables(()
+          beginFormalParameters((, MemberKind.NonStaticMethod)
+            beginMetadataStar(int)
+            endMetadataStar(0)
+            beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+              handleIdentifier(int, typeReference)
+              handleNoTypeArguments(value)
+              handleType(int, null)
+              handleIdentifier(value, formalParameterDeclaration)
+              handleFormalParameterWithoutValue())
+            endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+          endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
+          handleNoInitializers()
+          handleAsyncModifier(null, null)
+          handleEmptyFunctionBody(;)
+        endEnumConstructor(null, const, (, null, ;)
+      endMember()
+    endEnum(enum, {, 2)
+  endTopLevelDeclaration()
+endCompilationUnit(1, )

pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.intertwined.expect

@@ -0,0 +1,199 @@
+parseUnit(enum)
+  skipErrorTokens(enum)
+  listener: beginCompilationUnit(enum)
+  syntheticPreviousToken(enum)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(enum)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(, enum, Instance of 'DirectiveContext')
+      parseTopLevelKeywordModifiers(, enum)
+      parseEnum(enum)
+        listener: beginUncategorizedTopLevelDeclaration(enum)
+        ensureIdentifier(enum, enumDeclaration)
+          listener: handleIdentifier(E, enumDeclaration)
+        listener: beginEnum(enum)
+        parseEnumHeaderOpt(E, enum)
+          listener: beginTypeVariables(<)
+          parseMetadataStar(<)
+            listener: beginMetadataStar(X)
+            listener: endMetadataStar(0)
+          ensureIdentifier(<, typeVariableDeclaration)
+            listener: handleIdentifier(X, typeVariableDeclaration)
+          listener: beginTypeVariable(X)
+          parseMetadataStar(,)
+            listener: beginMetadataStar(Y)
+            listener: endMetadataStar(0)
+          ensureIdentifier(,, typeVariableDeclaration)
+            listener: handleIdentifier(Y, typeVariableDeclaration)
+          listener: beginTypeVariable(Y)
+          listener: handleTypeVariablesDefined(Y, 2)
+          listener: handleNoType(Y)
+          listener: endTypeVariable(>, 1, null, null)
+          listener: handleNoType(X)
+          listener: endTypeVariable(,, 0, null, null)
+          listener: endTypeVariables(<, >)
+          parseEnumWithClauseOpt(>)
+            listener: handleEnumNoWithClause()
+          parseClassOrMixinOrEnumImplementsOpt(>)
+            listener: handleImplements(null, 0)
+        listener: handleEnumHeader(enum, {)
+        parseEnumElement({)
+          parseMetadataStar({)
+            listener: beginMetadataStar(one)
+            listener: endMetadataStar(0)
+          ensureIdentifier({, enumValueDeclaration)
+            listener: handleIdentifier(one, enumValueDeclaration)
+          parseConstructorReference(one, ConstructorReferenceContext.Const, null, true)
+            listener: handleNoTypeNameInConstructorReference(<)
+            listener: beginConstructorReference(one)
+            listener: beginTypeArguments(<)
+            listener: handleIdentifier(int, typeReference)
+            listener: handleNoTypeArguments(,)
+            listener: handleType(int, null)
+            listener: handleIdentifier(String, typeReference)
+            listener: handleNoTypeArguments(>)
+            listener: handleType(String, null)
+            listener: endTypeArguments(2, <, >)
+            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+            listener: endConstructorReference(one, null, (, ConstructorReferenceContext.Const)
+          parseConstructorInvocationArguments(>)
+            parseArgumentsRest(()
+              listener: beginArguments(()
+              listener: endArguments(0, (, ))
+          listener: handleEnumElement({)
+        parseEnumElement(,)
+          parseMetadataStar(,)
+            listener: beginMetadataStar(two)
+            listener: endMetadataStar(0)
+          ensureIdentifier(,, enumValueDeclaration)
+            listener: handleIdentifier(two, enumValueDeclaration)
+          parseConstructorReference(two, ConstructorReferenceContext.Const, null, true)
+            listener: handleNoTypeNameInConstructorReference(<)
+            listener: beginConstructorReference(two)
+            listener: beginTypeArguments(<)
+            listener: handleIdentifier(double, typeReference)
+            listener: handleNoTypeArguments(,)
+            listener: handleType(double, null)
+            listener: handleIdentifier(num, typeReference)
+            listener: handleNoTypeArguments(>)
+            listener: handleType(num, null)
+            listener: endTypeArguments(2, <, >)
+            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+            listener: endConstructorReference(two, null, (, ConstructorReferenceContext.Const)
+          parseConstructorInvocationArguments(>)
+            parseArgumentsRest(()
+              listener: beginArguments(()
+              listener: endArguments(0, (, ))
+          listener: handleEnumElement(,)
+        parseEnumElement(,)
+          parseMetadataStar(,)
+            listener: beginMetadataStar(three)
+            listener: endMetadataStar(0)
+          ensureIdentifier(,, enumValueDeclaration)
+            listener: handleIdentifier(three, enumValueDeclaration)
+          parseConstructorReference(three, ConstructorReferenceContext.Const, null, true)
+            listener: handleNoTypeNameInConstructorReference(<)
+            listener: beginConstructorReference(three)
+            listener: beginTypeArguments(<)
+            listener: handleIdentifier(int, typeReference)
+            listener: handleNoTypeArguments(,)
+            listener: handleType(int, null)
+            listener: handleIdentifier(int, typeReference)
+            listener: handleNoTypeArguments(>)
+            listener: handleType(int, null)
+            listener: endTypeArguments(2, <, >)
+            ensureIdentifier(., constructorReferenceContinuationAfterTypeArguments)
+              listener: handleIdentifier(named, constructorReferenceContinuationAfterTypeArguments)
+            listener: endConstructorReference(three, ., (, ConstructorReferenceContext.Const)
+          parseConstructorInvocationArguments(named)
+            parseArgumentsRest(()
+              listener: beginArguments(()
+              parseExpression(()
+                parsePrecedenceExpression((, 1, true)
+                  parseUnaryExpression((, true)
+                    parsePrimary((, expression)
+                      parseLiteralInt(()
+                        listener: handleLiteralInt(42)
+              listener: endArguments(1, (, ))
+          listener: handleEnumElement(,)
+        listener: handleEnumElements(;, 3)
+        notEofOrValue(}, const)
+        parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Enum, E)
+          parseMetadataStar(;)
+            listener: beginMetadataStar(const)
+            listener: endMetadataStar(0)
+          listener: beginMember()
+          parseMethod(;, null, null, null, null, null, const, const, Instance of 'NoType', null, E, DeclarationKind.Enum, E, false)
+            listener: beginMethod(DeclarationKind.Enum, null, null, null, const, null, E)
+            listener: handleNoType(const)
+            ensureIdentifierPotentiallyRecovered(const, methodDeclaration, false)
+              listener: handleIdentifier(E, methodDeclaration)
+            parseQualifiedRestOpt(E, methodDeclarationContinuation)
+            parseMethodTypeVar(E)
+              listener: handleNoTypeVariables(()
+            parseGetterOrFormalParameters(E, E, false, MemberKind.NonStaticMethod)
+              parseFormalParameters(E, MemberKind.NonStaticMethod)
+                parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                  listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                  listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
+            parseInitializersOpt())
+              listener: handleNoInitializers()
+            parseAsyncModifierOpt())
+              listener: handleAsyncModifier(null, null)
+              inPlainSync()
+            inPlainSync()
+            parseFunctionBody(), false, true)
+              listener: handleEmptyFunctionBody(;)
+            listener: endEnumConstructor(null, const, (, null, ;)
+          listener: endMember()
+        notEofOrValue(}, const)
+        parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Enum, E)
+          parseMetadataStar(;)
+            listener: beginMetadataStar(const)
+            listener: endMetadataStar(0)
+          listener: beginMember()
+          parseMethod(;, null, null, null, null, null, const, const, Instance of 'NoType', null, E, DeclarationKind.Enum, E, false)
+            listener: beginMethod(DeclarationKind.Enum, null, null, null, const, null, E)
+            listener: handleNoType(const)
+            ensureIdentifierPotentiallyRecovered(const, methodDeclaration, false)
+              listener: handleIdentifier(E, methodDeclaration)
+            parseQualifiedRestOpt(E, methodDeclarationContinuation)
+              parseQualifiedRest(E, methodDeclarationContinuation)
+                ensureIdentifier(., methodDeclarationContinuation)
+                  listener: handleIdentifier(named, methodDeclarationContinuation)
+                listener: handleQualified(.)
+            parseMethodTypeVar(named)
+              listener: handleNoTypeVariables(()
+            parseGetterOrFormalParameters(named, E, false, MemberKind.NonStaticMethod)
+              parseFormalParameters(named, MemberKind.NonStaticMethod)
+                parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                  listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                  parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                    parseMetadataStar(()
+                      listener: beginMetadataStar(int)
+                      listener: endMetadataStar(0)
+                    listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
+                    listener: handleIdentifier(int, typeReference)
+                    listener: handleNoTypeArguments(value)
+                    listener: handleType(int, null)
+                    ensureIdentifier(int, formalParameterDeclaration)
+                      listener: handleIdentifier(value, formalParameterDeclaration)
+                    listener: handleFormalParameterWithoutValue())
+                    listener: endFormalParameter(null, null, null, value, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
+                  listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
+            parseInitializersOpt())
+              listener: handleNoInitializers()
+            parseAsyncModifierOpt())
+              listener: handleAsyncModifier(null, null)
+              inPlainSync()
+            inPlainSync()
+            parseFunctionBody(), false, true)
+              listener: handleEmptyFunctionBody(;)
+            listener: endEnumConstructor(null, const, (, null, ;)
+          listener: endMember()
+        notEofOrValue(}, })
+        listener: endEnum(enum, {, 2)
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(enum)
+  listener: endCompilationUnit(1, )

pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.parser.expect

@@ -0,0 +1,19 @@
+enum E<X, Y> {
+one<int, String>(),
+two<double, num>(),
+three<int, int>.named(42);
+
+const E();
+const E.named(int value);
+}
+
+
+enum[KeywordToken] E[StringToken]<[BeginToken]X[StringToken],[SimpleToken] Y[StringToken]>[SimpleToken] {[BeginToken]
+one[StringToken]<[BeginToken]int[StringToken],[SimpleToken] String[StringToken]>[SimpleToken]([BeginToken])[SimpleToken],[SimpleToken]
+two[StringToken]<[BeginToken]double[StringToken],[SimpleToken] num[StringToken]>[SimpleToken]([BeginToken])[SimpleToken],[SimpleToken]
+three[StringToken]<[BeginToken]int[StringToken],[SimpleToken] int[StringToken]>[SimpleToken].[SimpleToken]named[StringToken]([BeginToken]42[StringToken])[SimpleToken];[SimpleToken]
+
+const[KeywordToken] E[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+const[KeywordToken] E[StringToken].[SimpleToken]named[StringToken]([BeginToken]int[StringToken] value[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+[SimpleToken]

pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.scanner.expect

@@ -0,0 +1,19 @@
+enum E<X, Y> {
+one<int, String>(),
+two<double, num>(),
+three<int, int>.named(42);
+
+const E();
+const E.named(int value);
+}
+
+
+enum[KeywordToken] E[StringToken]<[BeginToken]X[StringToken],[SimpleToken] Y[StringToken]>[SimpleToken] {[BeginToken]
+one[StringToken]<[BeginToken]int[StringToken],[SimpleToken] String[StringToken]>[SimpleToken]([BeginToken])[SimpleToken],[SimpleToken]
+two[StringToken]<[BeginToken]double[StringToken],[SimpleToken] num[StringToken]>[SimpleToken]([BeginToken])[SimpleToken],[SimpleToken]
+three[StringToken]<[BeginToken]int[StringToken],[SimpleToken] int[StringToken]>[SimpleToken].[SimpleToken]named[StringToken]([BeginToken]42[StringToken])[SimpleToken];[SimpleToken]
+
+const[KeywordToken] E[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
+const[KeywordToken] E[StringToken].[SimpleToken]named[StringToken]([BeginToken]int[StringToken] value[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+[SimpleToken]

pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.expect

@@ -18,7 +18,7 @@ beginCompilationUnit(class)
       handleNoType(C)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(C)
@@ -118,7 +118,7 @@ beginCompilationUnit(class)
       handleNoType(D)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(D)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(C)
               listener: handleNoType(C)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(C)
+            parseClassWithClauseOpt(C)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(C)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(C)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(C, DeclarationKind.Class, C)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, C)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, C)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, C)
               parseMetadataStar({)
                 listener: beginMetadataStar(C)
                 listener: endMetadataStar(0)
@@ -71,7 +71,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, C, (, null, ;)
               listener: endMember()
             notEofOrValue(}, C)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, C)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, C)
               parseMetadataStar(;)
                 listener: beginMetadataStar(C)
                 listener: endMetadataStar(0)
@@ -271,15 +271,15 @@ parseUnit(class)
             parseClassExtendsOpt(D)
               listener: handleNoType(D)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(D)
+            parseClassWithClauseOpt(D)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(D)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(D)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(D, DeclarationKind.Class, D)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, D)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, D)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, D)
               parseMetadataStar({)
                 listener: beginMetadataStar(D)
                 listener: endMetadataStar(0)
@@ -323,7 +323,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, D, (, null, ;)
               listener: endMember()
             notEofOrValue(}, D)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, D)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, D)
               parseMetadataStar(;)
                 listener: beginMetadataStar(D)
                 listener: endMetadataStar(0)

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

@@ -40,7 +40,7 @@ parseUnit(UnmatchedToken(())
                             parseNewExpression({)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
-                              parseConstructorReference(new, ConstructorReferenceContext.New, null)
+                              parseConstructorReference(new, ConstructorReferenceContext.New, null, false)
                                 ensureIdentifier(new, constructorReference)
                                   listener: handleIdentifier(C, constructorReference)
                                 listener: beginConstructorReference(C)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.expect

@@ -130,7 +130,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(foo)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, foo)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(foo)
                 listener: endMetadataStar(0)
@@ -65,7 +65,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, foo, (, null, })
               listener: endMember()
             notEofOrValue(}, foo)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(foo)
                 listener: endMetadataStar(0)
@@ -128,7 +128,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, foo, (, :, })
               listener: endMember()
             notEofOrValue(}, foo)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(foo)
                 listener: endMetadataStar(0)
@@ -187,7 +187,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, foo, (, :, })
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -224,7 +224,7 @@ parseUnit(class)
                 listener: endClassMethod(get, get, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Foo)
               parseMetadataStar(;)
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -268,7 +268,7 @@ parseUnit(class)
                 listener: endClassMethod(get, get, {, null, })
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -315,7 +315,7 @@ parseUnit(class)
                 listener: endClassConstructor(get, get, (, null, ;)
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Foo)
               parseMetadataStar(;)
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -369,7 +369,7 @@ parseUnit(class)
                 listener: endClassConstructor(get, get, (, null, })
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -437,7 +437,7 @@ parseUnit(class)
                 listener: endClassConstructor(get, get, (, :, ;)
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Foo)
               parseMetadataStar(;)
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -516,7 +516,7 @@ parseUnit(class)
                 listener: endClassConstructor(get, get, (, :, })
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -559,7 +559,7 @@ parseUnit(class)
                 listener: endClassMethod(set, set, (, null, ;)
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Foo)
               parseMetadataStar(;)
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -609,7 +609,7 @@ parseUnit(class)
                 listener: endClassMethod(set, set, (, null, })
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -656,7 +656,7 @@ parseUnit(class)
                 listener: endClassConstructor(set, set, (, null, ;)
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Foo)
               parseMetadataStar(;)
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -710,7 +710,7 @@ parseUnit(class)
                 listener: endClassConstructor(set, set, (, null, })
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -778,7 +778,7 @@ parseUnit(class)
                 listener: endClassConstructor(set, set, (, :, ;)
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Foo)
               parseMetadataStar(;)
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -857,7 +857,7 @@ parseUnit(class)
                 listener: endClassConstructor(set, set, (, :, })
               listener: endMember()
             notEofOrValue(}, external)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(external)
                 listener: endMetadataStar(0)
@@ -914,7 +914,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, external, (, :, ;)
               listener: endMember()
             notEofOrValue(}, external)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Foo)
               parseMetadataStar(;)
                 listener: beginMetadataStar(external)
                 listener: endMetadataStar(0)
@@ -993,7 +993,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, external, (, :, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1012,7 +1012,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, null, 1, int, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Foo)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.expect

@@ -38,7 +38,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(get)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -66,7 +66,7 @@ parseUnit(class)
                 listener: endClassConstructor(get, get, (, null, })
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -130,7 +130,7 @@ parseUnit(class)
                 listener: endClassConstructor(get, get, (, :, })
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.expect

@@ -34,7 +34,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(void)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, void)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(void)
                 listener: endMetadataStar(0)
@@ -66,7 +66,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, void, (, null, })
               listener: endMember()
             notEofOrValue(}, void)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(void)
                 listener: endMetadataStar(0)
@@ -130,7 +130,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, void, (, :, })
               listener: endMember()
             notEofOrValue(}, void)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(void)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.expect

@@ -34,7 +34,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(set)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -66,7 +66,7 @@ parseUnit(class)
                 listener: endClassConstructor(set, set, (, null, })
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -130,7 +130,7 @@ parseUnit(class)
                 listener: endClassConstructor(set, set, (, :, })
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.expect

@@ -34,7 +34,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(get)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -62,7 +62,7 @@ parseUnit(class)
                 listener: endClassMethod(get, get, (, null, })
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -122,7 +122,7 @@ parseUnit(class)
                 listener: endClassConstructor(get, get, (, :, })
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)
@@ -159,7 +159,7 @@ parseUnit(class)
                 listener: endClassConstructor(get, get, (, null, })
               listener: endMember()
             notEofOrValue(}, get)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(get)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.expect

@@ -8,7 +8,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(Foo)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, Foo)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(Foo)
                 listener: endMetadataStar(0)
@@ -59,7 +59,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, Foo, (, null, })
               listener: endMember()
             notEofOrValue(}, Foo)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(Foo)
                 listener: endMetadataStar(0)
@@ -116,7 +116,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, Foo, (, :, })
               listener: endMember()
             notEofOrValue(}, Foo)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(Foo)
                 listener: endMetadataStar(0)
@@ -152,7 +152,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, Foo, (, null, })
               listener: endMember()
             notEofOrValue(}, Foo)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(Foo)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_operator.crash_dart.expect

@@ -82,7 +82,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(Foo)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_operator.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, Foo)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(Foo)
                 listener: endMetadataStar(0)
@@ -63,7 +63,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, Foo, (, null, })
               listener: endMember()
             notEofOrValue(}, /)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(/)
                 listener: endMetadataStar(0)
@@ -122,7 +122,7 @@ parseUnit(class)
                     listener: endClassConstructor(null, operator, (, :, })
                   listener: endMember()
             notEofOrValue(}, Foo)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(Foo)
                 listener: endMetadataStar(0)
@@ -158,7 +158,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, Foo, (, null, })
               listener: endMember()
             notEofOrValue(}, .)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(.)
                 listener: endMetadataStar(0)
@@ -169,7 +169,7 @@ parseUnit(class)
                 listener: handleInvalidMember(.)
                 listener: endMember()
             notEofOrValue(}, /)
-            parseClassOrMixinOrExtensionMemberImpl(., DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(., DeclarationKind.Class, Foo)
               parseMetadataStar(.)
                 listener: beginMetadataStar(/)
                 listener: endMetadataStar(0)
@@ -228,7 +228,7 @@ parseUnit(class)
                     listener: endClassConstructor(null, operator, (, :, })
                   listener: endMember()
             notEofOrValue(}, foo)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(foo)
                 listener: endMetadataStar(0)
@@ -264,7 +264,7 @@ parseUnit(class)
                 listener: endClassMethod(null, foo, (, null, })
               listener: endMember()
             notEofOrValue(}, /)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(/)
                 listener: endMetadataStar(0)
@@ -323,7 +323,7 @@ parseUnit(class)
                     listener: endClassConstructor(null, operator, (, :, })
                   listener: endMember()
             notEofOrValue(}, foo)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(foo)
                 listener: endMetadataStar(0)
@@ -359,7 +359,7 @@ parseUnit(class)
                 listener: endClassMethod(null, foo, (, null, })
               listener: endMember()
             notEofOrValue(}, .)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(.)
                 listener: endMetadataStar(0)
@@ -370,7 +370,7 @@ parseUnit(class)
                 listener: handleInvalidMember(.)
                 listener: endMember()
             notEofOrValue(}, /)
-            parseClassOrMixinOrExtensionMemberImpl(., DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(., DeclarationKind.Class, Foo)
               parseMetadataStar(.)
                 listener: beginMetadataStar(/)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(void)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, void)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(void)
                 listener: endMetadataStar(0)
@@ -60,7 +60,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, void, (, null, })
               listener: endMember()
             notEofOrValue(}, void)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(void)
                 listener: endMetadataStar(0)
@@ -118,7 +118,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, void, (, :, })
               listener: endMember()
             notEofOrValue(}, void)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(void)
                 listener: endMetadataStar(0)
@@ -155,7 +155,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, void, (, null, })
               listener: endMember()
             notEofOrValue(}, void)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(void)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(Foo)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(set)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(Foo)
               listener: handleNoType(Foo)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Foo)
+            parseClassWithClauseOpt(Foo)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Foo)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Foo)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -60,7 +60,7 @@ parseUnit(class)
                 listener: endClassMethod(set, set, (, null, })
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -118,7 +118,7 @@ parseUnit(class)
                 listener: endClassConstructor(set, set, (, :, })
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)
@@ -155,7 +155,7 @@ parseUnit(class)
                 listener: endClassConstructor(set, set, (, null, })
               listener: endMember()
             notEofOrValue(}, set)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Foo)
               parseMetadataStar(})
                 listener: beginMetadataStar(set)
                 listener: endMetadataStar(0)

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

@@ -35,7 +35,7 @@ parseUnit(extension)
         parseClassOrMixinOrExtensionBody(>, DeclarationKind.Extension, E)
           listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Extension, {)
           notEofOrValue(}, bool)
-          parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Extension, E)
+          parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Extension, E)
             parseMetadataStar({)
               listener: beginMetadataStar(bool)
               listener: endMetadataStar(0)
@@ -92,7 +92,7 @@ parseUnit(extension)
               listener: endExtensionMethod(null, bool, (, null, })
             listener: endMember()
           notEofOrValue(}, int)
-          parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Extension, E)
+          parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Extension, E)
             parseMetadataStar(})
               listener: beginMetadataStar(int)
               listener: endMetadataStar(0)
@@ -129,7 +129,7 @@ parseUnit(extension)
               listener: endExtensionMethod(get, int, =>, null, ;)
             listener: endMember()
           notEofOrValue(}, set)
-          parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Extension, E)
+          parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Extension, E)
             parseMetadataStar(;)
               listener: beginMetadataStar(set)
               listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_000032.dart.expect

@@ -30,7 +30,7 @@ beginCompilationUnit(class)
       handleNoType(C)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(C)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(C)
               listener: handleNoType(C)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(C)
+            parseClassWithClauseOpt(C)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(C)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(C)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(C, DeclarationKind.Class, C)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, C)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, C)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, C)
               parseMetadataStar({)
                 listener: beginMetadataStar(C)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_22313.dart.expect

@@ -30,7 +30,7 @@ beginCompilationUnit(class)
       handleNoType(A)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -45,7 +45,7 @@ beginCompilationUnit(class)
       handleNoType(B)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -66,7 +66,7 @@ beginCompilationUnit(class)
       handleType(B, null)
       handleClassExtends(extends, 2)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(Foo)
@@ -96,7 +96,7 @@ beginCompilationUnit(class)
       handleNoType(Bar)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       handleRecoverableError(Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}], extend, extend)
       handleIdentifier(A, typeReference)
@@ -108,7 +108,7 @@ beginCompilationUnit(class)
       handleType(B, null)
       handleClassExtends(extend, 2)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleRecoverClassHeader()
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(Bar)
@@ -138,7 +138,7 @@ beginCompilationUnit(class)
       handleNoType(Baz)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       handleRecoverableError(Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}], on, on)
       handleIdentifier(A, typeReference)
@@ -150,7 +150,7 @@ beginCompilationUnit(class)
       handleType(B, null)
       handleClassExtends(on, 2)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleRecoverClassHeader()
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(Baz)

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

@@ -19,10 +19,10 @@ parseUnit(class)
             parseClassExtendsOpt(A)
               listener: handleNoType(A)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(A)
+            parseClassWithClauseOpt(A)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(A)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(A)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, A)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -47,10 +47,10 @@ parseUnit(class)
             parseClassExtendsOpt(B)
               listener: handleNoType(B)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(B)
+            parseClassWithClauseOpt(B)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(B)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(B)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(B, DeclarationKind.Class, B)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -83,15 +83,15 @@ parseUnit(class)
                 listener: handleNoTypeArguments({)
                 listener: handleType(B, null)
                 listener: handleClassExtends(extends, 2)
-            parseWithClauseOpt(B)
+            parseClassWithClauseOpt(B)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(B)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(B)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(B, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, Foo)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(Foo)
                 listener: endMetadataStar(0)
@@ -143,16 +143,16 @@ parseUnit(class)
             parseClassExtendsOpt(Bar)
               listener: handleNoType(Bar)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Bar)
+            parseClassWithClauseOpt(Bar)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Bar)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Bar)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassHeaderRecovery(Bar, class, class)
             parseClassHeaderOpt(Bar, class, class)
               parseClassExtendsOpt(Bar)
-              parseWithClauseOpt(Bar)
-              parseClassOrMixinImplementsOpt(Bar)
+              parseClassWithClauseOpt(Bar)
+              parseClassOrMixinOrEnumImplementsOpt(Bar)
             skipUnexpectedTokenOpt(Bar, [extends, with, implements, {])
             reportRecoverableError(extend, Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}])
               listener: handleRecoverableError(Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}], extend, extend)
@@ -166,16 +166,16 @@ parseUnit(class)
               listener: handleNoTypeArguments({)
               listener: handleType(B, null)
               listener: handleClassExtends(extend, 2)
-            parseWithClauseOpt(B)
+            parseClassWithClauseOpt(B)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(B)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(B)
+              listener: handleImplements(null, 0)
             listener: handleRecoverClassHeader()
           ensureBlock(B, null, class declaration)
           parseClassOrMixinOrExtensionBody(B, DeclarationKind.Class, Bar)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, Bar)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Bar)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Bar)
               parseMetadataStar({)
                 listener: beginMetadataStar(Bar)
                 listener: endMetadataStar(0)
@@ -227,16 +227,16 @@ parseUnit(class)
             parseClassExtendsOpt(Baz)
               listener: handleNoType(Baz)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Baz)
+            parseClassWithClauseOpt(Baz)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Baz)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Baz)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassHeaderRecovery(Baz, class, class)
             parseClassHeaderOpt(Baz, class, class)
               parseClassExtendsOpt(Baz)
-              parseWithClauseOpt(Baz)
-              parseClassOrMixinImplementsOpt(Baz)
+              parseClassWithClauseOpt(Baz)
+              parseClassOrMixinOrEnumImplementsOpt(Baz)
             skipUnexpectedTokenOpt(Baz, [extends, with, implements, {])
             reportRecoverableError(on, Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}])
               listener: handleRecoverableError(Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}], on, on)
@@ -250,16 +250,16 @@ parseUnit(class)
               listener: handleNoTypeArguments({)
               listener: handleType(B, null)
               listener: handleClassExtends(on, 2)
-            parseWithClauseOpt(B)
+            parseClassWithClauseOpt(B)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(B)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(B)
+              listener: handleImplements(null, 0)
             listener: handleRecoverClassHeader()
           ensureBlock(B, null, class declaration)
           parseClassOrMixinOrExtensionBody(B, DeclarationKind.Class, Baz)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, Baz)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Baz)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Baz)
               parseMetadataStar({)
                 listener: beginMetadataStar(Baz)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.expect

@@ -29,7 +29,7 @@ beginCompilationUnit(const)
       handleNoType(Annotation)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)
@@ -84,7 +84,7 @@ beginCompilationUnit(const)
       handleNoType(>)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -99,7 +99,7 @@ beginCompilationUnit(const)
       handleNoType(C)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(m)

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

@@ -41,15 +41,15 @@ parseUnit(const)
             parseClassExtendsOpt(Annotation)
               listener: handleNoType(Annotation)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Annotation)
+            parseClassWithClauseOpt(Annotation)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Annotation)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Annotation)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Annotation, DeclarationKind.Class, Annotation)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Annotation)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Annotation)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -66,7 +66,7 @@ parseUnit(const)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, const)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Annotation)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Annotation)
               parseMetadataStar(;)
                 listener: beginMetadataStar(const)
                 listener: endMetadataStar(0)
@@ -133,10 +133,10 @@ parseUnit(const)
             parseClassExtendsOpt(>)
               listener: handleNoType(>)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(>)
+            parseClassWithClauseOpt(>)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(>)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(>)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(>, DeclarationKind.Class, A)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -161,15 +161,15 @@ parseUnit(const)
             parseClassExtendsOpt(C)
               listener: handleNoType(C)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(C)
+            parseClassWithClauseOpt(C)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(C)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(C)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(C, DeclarationKind.Class, C)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, m)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, C)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, C)
               parseMetadataStar({)
                 listener: beginMetadataStar(m)
                 listener: endMetadataStar(0)
@@ -203,7 +203,7 @@ parseUnit(const)
                             parseNewExpression(=>)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
-                              parseConstructorReference(new, ConstructorReferenceContext.New, null)
+                              parseConstructorReference(new, ConstructorReferenceContext.New, null, false)
                                 ensureIdentifier(new, constructorReference)
                                   listener: handleIdentifier(A, constructorReference)
                                 listener: beginConstructorReference(A)

pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.expect

@@ -70,7 +70,7 @@ beginCompilationUnit(abstract)
       handleNoType(Key)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(abstract, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(int)

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

@@ -20,15 +20,15 @@ parseUnit(abstract)
             parseClassExtendsOpt(Key)
               listener: handleNoType(Key)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Key)
+            parseClassWithClauseOpt(Key)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Key)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Key)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(abstract, class, null)
           parseClassOrMixinOrExtensionBody(Key, DeclarationKind.Class, Key)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Key)
               parseMetadataStar({)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -115,7 +115,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -188,7 +188,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -282,7 +282,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -362,7 +362,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -468,7 +468,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -555,7 +555,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -668,7 +668,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -762,7 +762,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -859,7 +859,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -944,7 +944,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1048,7 +1048,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1140,7 +1140,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1279,7 +1279,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1406,7 +1406,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1522,7 +1522,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1621,7 +1621,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1744,7 +1744,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1850,7 +1850,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, s)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(s)
                 listener: endMetadataStar(0)
@@ -2088,7 +2088,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, s, (, null, })
               listener: endMember()
             notEofOrValue(}, Key)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(Key)
                 listener: endMetadataStar(0)
@@ -2333,7 +2333,7 @@ parseUnit(abstract)
                 listener: endClassConstructor(null, Key, (, :, })
               listener: endMember()
             notEofOrValue(}, Key)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(Key)
                 listener: endMetadataStar(0)
@@ -2542,7 +2542,7 @@ parseUnit(abstract)
                 listener: endClassConstructor(null, Key, (, :, })
               listener: endMember()
             notEofOrValue(}, not_currently_working)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(not_currently_working)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.expect

@@ -70,7 +70,7 @@ beginCompilationUnit(abstract)
       handleNoType(Key)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(abstract, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(int)

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

@@ -20,15 +20,15 @@ parseUnit(abstract)
             parseClassExtendsOpt(Key)
               listener: handleNoType(Key)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Key)
+            parseClassWithClauseOpt(Key)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Key)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Key)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(abstract, class, null)
           parseClassOrMixinOrExtensionBody(Key, DeclarationKind.Class, Key)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Key)
               parseMetadataStar({)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -115,7 +115,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -188,7 +188,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -282,7 +282,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -362,7 +362,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -469,7 +469,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -556,7 +556,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -670,7 +670,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -764,7 +764,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -861,7 +861,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -946,7 +946,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1050,7 +1050,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1142,7 +1142,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1281,7 +1281,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1408,7 +1408,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1525,7 +1525,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1624,7 +1624,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1748,7 +1748,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1854,7 +1854,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, s)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(s)
                 listener: endMetadataStar(0)
@@ -2092,7 +2092,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, s, (, null, })
               listener: endMember()
             notEofOrValue(}, Key)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(Key)
                 listener: endMetadataStar(0)
@@ -2337,7 +2337,7 @@ parseUnit(abstract)
                 listener: endClassConstructor(null, Key, (, :, })
               listener: endMember()
             notEofOrValue(}, Key)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(Key)
                 listener: endMetadataStar(0)
@@ -2546,7 +2546,7 @@ parseUnit(abstract)
                 listener: endClassConstructor(null, Key, (, :, })
               listener: endMember()
             notEofOrValue(}, not_currently_working)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(not_currently_working)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.expect

@@ -70,7 +70,7 @@ beginCompilationUnit(abstract)
       handleNoType(Key)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(abstract, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(int)

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

@@ -20,15 +20,15 @@ parseUnit(abstract)
             parseClassExtendsOpt(Key)
               listener: handleNoType(Key)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Key)
+            parseClassWithClauseOpt(Key)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Key)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Key)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(abstract, class, null)
           parseClassOrMixinOrExtensionBody(Key, DeclarationKind.Class, Key)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Key)
               parseMetadataStar({)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -115,7 +115,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -188,7 +188,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -282,7 +282,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -362,7 +362,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -469,7 +469,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -556,7 +556,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, =>, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -670,7 +670,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -764,7 +764,7 @@ parseUnit(abstract)
                 listener: endClassMethod(get, int, {, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -861,7 +861,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -946,7 +946,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1050,7 +1050,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1142,7 +1142,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1281,7 +1281,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1408,7 +1408,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1525,7 +1525,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1624,7 +1624,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, ;)
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Key)
               parseMetadataStar(;)
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1748,7 +1748,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, int)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(int)
                 listener: endMetadataStar(0)
@@ -1854,7 +1854,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, int, (, null, })
               listener: endMember()
             notEofOrValue(}, s)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(s)
                 listener: endMetadataStar(0)
@@ -2092,7 +2092,7 @@ parseUnit(abstract)
                 listener: endClassMethod(null, s, (, null, })
               listener: endMember()
             notEofOrValue(}, Key)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(Key)
                 listener: endMetadataStar(0)
@@ -2337,7 +2337,7 @@ parseUnit(abstract)
                 listener: endClassConstructor(null, Key, (, :, })
               listener: endMember()
             notEofOrValue(}, Key)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(Key)
                 listener: endMetadataStar(0)
@@ -2546,7 +2546,7 @@ parseUnit(abstract)
                 listener: endClassConstructor(null, Key, (, :, })
               listener: endMember()
             notEofOrValue(}, not_currently_working)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Key)
               parseMetadataStar(})
                 listener: beginMetadataStar(not_currently_working)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_39026.crash_dart.expect

@@ -18,7 +18,7 @@ beginCompilationUnit(class)
       handleNoType(A)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(co)

pkg/front_end/parser_testcases/error_recovery/issue_39026.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(A)
               listener: handleNoType(A)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(A)
+            parseClassWithClauseOpt(A)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(A)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(A)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, A)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, co)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, A)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, A)
               parseMetadataStar({)
                 listener: beginMetadataStar(co)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_39026_prime.crash_dart.expect

@@ -14,7 +14,7 @@ beginCompilationUnit(class)
       handleNoType(A)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(co)

pkg/front_end/parser_testcases/error_recovery/issue_39026_prime.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(A)
               listener: handleNoType(A)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(A)
+            parseClassWithClauseOpt(A)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(A)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(A)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, A)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, co)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, A)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, A)
               parseMetadataStar({)
                 listener: beginMetadataStar(co)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_39230.crash_dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(C)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(C)

pkg/front_end/parser_testcases/error_recovery/issue_39230.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(C)
               listener: handleNoType(C)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(C)
+            parseClassWithClauseOpt(C)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(C)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(C)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(C, DeclarationKind.Class, C)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, C)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, C)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, C)
               parseMetadataStar({)
                 listener: beginMetadataStar(C)
                 listener: endMetadataStar(0)
@@ -63,7 +63,7 @@ parseUnit(class)
                 listener: endClassConstructor(null, C, (, null, })
               listener: endMember()
             notEofOrValue(}, /)
-            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, C)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, C)
               parseMetadataStar(})
                 listener: beginMetadataStar(/)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_41265.crash_dart.expect

@@ -22,7 +22,7 @@ beginCompilationUnit(class)
       handleNoType(>)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -43,7 +43,7 @@ beginCompilationUnit(class)
     endTypeVariables(<, >)
     beginMixinDeclaration(mixin, M)
       handleMixinOn(null, 0)
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleMixinHeader(mixin)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Mixin, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Mixin, 0, {, })
@@ -74,13 +74,13 @@ beginCompilationUnit(class)
         endFunctionType(Function, null)
       endTypeList(1)
       handleClassWithClause(with)
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       handleRecoverableError(Message[UnexpectedToken, Unexpected token '>'., null, {lexeme: >}], >, >)
       handleNoType(>)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleRecoverClassHeader()
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })

pkg/front_end/parser_testcases/error_recovery/issue_41265.crash_dart.intertwined.expect

@@ -27,10 +27,10 @@ parseUnit(class)
             parseClassExtendsOpt(>)
               listener: handleNoType(>)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(>)
+            parseClassWithClauseOpt(>)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(>)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(>)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(>, DeclarationKind.Class, A)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -61,8 +61,8 @@ parseUnit(class)
         parseMixinHeaderOpt(>, mixin)
           parseMixinOnOpt(>)
             listener: handleMixinOn(null, 0)
-          parseClassOrMixinImplementsOpt(>)
-            listener: handleClassOrMixinImplements(null, 0)
+          parseClassOrMixinOrEnumImplementsOpt(>)
+            listener: handleImplements(null, 0)
           listener: handleMixinHeader(mixin)
         parseClassOrMixinOrExtensionBody(>, DeclarationKind.Mixin, M)
           listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Mixin, {)
@@ -90,7 +90,7 @@ parseUnit(class)
                 listener: handleNoTypeArguments(with)
                 listener: handleType(Object, null)
                 listener: handleClassExtends(extends, 1)
-            parseWithClauseOpt(Object)
+            parseClassWithClauseOpt(Object)
               parseTypeList(with)
                 listener: beginTypeList(M)
                 listener: beginFunctionType(M)
@@ -110,29 +110,29 @@ parseUnit(class)
                 listener: endFunctionType(Function, null)
                 listener: endTypeList(1)
               listener: handleClassWithClause(with)
-            parseClassOrMixinImplementsOpt())
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt())
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassHeaderRecovery(DND1, class, class)
             parseClassHeaderOpt(DND1, class, class)
               parseClassExtendsOpt(DND1)
                 parseClassExtendsSeenExtendsClause(extends, DND1)
-              parseWithClauseOpt(Object)
+              parseClassWithClauseOpt(Object)
                 parseTypeList(with)
                   ensureIdentifier(with, typeReference)
                   parseFormalParametersRequiredOpt(Function, MemberKind.GeneralizedFunctionType)
                     parseFormalParametersRest((, MemberKind.GeneralizedFunctionType)
-              parseClassOrMixinImplementsOpt())
+              parseClassOrMixinOrEnumImplementsOpt())
             skipUnexpectedTokenOpt(), [extends, with, implements, {])
               reportRecoverableErrorWithToken(>, Instance of 'Template<(Token) => Message>')
                 listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token '>'., null, {lexeme: >}], >, >)
             parseClassExtendsOpt(>)
               listener: handleNoType(>)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(>)
+            parseClassWithClauseOpt(>)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(>)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(>)
+              listener: handleImplements(null, 0)
             listener: handleRecoverClassHeader()
           ensureBlock(>, null, class declaration)
           parseClassOrMixinOrExtensionBody(>, DeclarationKind.Class, DND1)

pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -78,7 +78,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -123,7 +123,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -162,7 +162,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -216,7 +216,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -259,7 +259,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -325,7 +325,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -379,7 +379,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -439,7 +439,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45251_const.dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -77,7 +77,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -125,7 +125,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -163,7 +163,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -191,7 +191,7 @@ parseUnit(class)
                         parsePrimary(=, expression)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
-                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo')
+                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo', false)
                               ensureIdentifier(const, constructorReference)
                                 listener: handleIdentifier(Map, constructorReference)
                               listener: beginConstructorReference(Map)
@@ -219,7 +219,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -247,7 +247,7 @@ parseUnit(class)
                         parsePrimary(=, expression)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
-                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg')
+                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg', false)
                               ensureIdentifier(const, constructorReference)
                                 listener: handleIdentifier(Map, constructorReference)
                               listener: beginConstructorReference(Map)
@@ -264,7 +264,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -329,7 +329,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -382,7 +382,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -445,7 +445,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.expect

@@ -22,7 +22,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -74,7 +74,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -115,7 +115,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -153,7 +153,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -200,7 +200,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -239,7 +239,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -289,7 +289,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -332,7 +332,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -376,7 +376,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45251_list_const.dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -73,7 +73,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -117,7 +117,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -154,7 +154,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -178,7 +178,7 @@ parseUnit(class)
                         parsePrimary(=, expression)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
-                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo')
+                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo', false)
                               ensureIdentifier(const, constructorReference)
                                 listener: handleIdentifier(List, constructorReference)
                               listener: beginConstructorReference(List)
@@ -203,7 +203,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -227,7 +227,7 @@ parseUnit(class)
                         parsePrimary(=, expression)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
-                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg')
+                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg', false)
                               ensureIdentifier(const, constructorReference)
                                 listener: handleIdentifier(List, constructorReference)
                               listener: beginConstructorReference(List)
@@ -244,7 +244,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -293,7 +293,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -333,7 +333,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -380,7 +380,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.expect

@@ -38,7 +38,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -73,7 +73,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -119,7 +119,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -156,7 +156,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -181,7 +181,7 @@ parseUnit(class)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
-                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'ComplexTypeParamOrArgInfo')
+                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'ComplexTypeParamOrArgInfo', false)
                               ensureIdentifier(new, constructorReference)
                                 listener: handleIdentifier(List, constructorReference)
                               listener: beginConstructorReference(List)
@@ -206,7 +206,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -231,7 +231,7 @@ parseUnit(class)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
-                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'NoTypeParamOrArg')
+                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'NoTypeParamOrArg', false)
                               ensureIdentifier(new, constructorReference)
                                 listener: handleIdentifier(List, constructorReference)
                               listener: beginConstructorReference(List)
@@ -248,7 +248,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -297,7 +297,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -337,7 +337,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -386,7 +386,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.expect

@@ -38,7 +38,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -77,7 +77,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -127,7 +127,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -165,7 +165,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -194,7 +194,7 @@ parseUnit(class)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
-                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'ComplexTypeParamOrArgInfo')
+                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'ComplexTypeParamOrArgInfo', false)
                               ensureIdentifier(new, constructorReference)
                                 listener: handleIdentifier(Map, constructorReference)
                               listener: beginConstructorReference(Map)
@@ -222,7 +222,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -251,7 +251,7 @@ parseUnit(class)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
-                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'NoTypeParamOrArg')
+                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'NoTypeParamOrArg', false)
                               ensureIdentifier(new, constructorReference)
                                 listener: handleIdentifier(Map, constructorReference)
                               listener: beginConstructorReference(Map)
@@ -268,7 +268,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -333,7 +333,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -386,7 +386,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -451,7 +451,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -71,7 +71,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -109,7 +109,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -144,7 +144,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -191,7 +191,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -230,7 +230,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -280,7 +280,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -321,7 +321,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -365,7 +365,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45251_set_const.dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -70,7 +70,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -111,7 +111,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -145,7 +145,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -169,7 +169,7 @@ parseUnit(class)
                         parsePrimary(=, expression)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
-                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo')
+                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo', false)
                               ensureIdentifier(const, constructorReference)
                                 listener: handleIdentifier(Set, constructorReference)
                               listener: beginConstructorReference(Set)
@@ -194,7 +194,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -218,7 +218,7 @@ parseUnit(class)
                         parsePrimary(=, expression)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
-                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg')
+                            parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg', false)
                               ensureIdentifier(const, constructorReference)
                                 listener: handleIdentifier(Set, constructorReference)
                               listener: beginConstructorReference(Set)
@@ -235,7 +235,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -284,7 +284,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -324,7 +324,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -371,7 +371,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.expect

@@ -38,7 +38,7 @@ beginCompilationUnit(class)
       handleNoType(F)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(final)

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

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(F)
               listener: handleNoType(F)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(F)
+            parseClassWithClauseOpt(F)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(F)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(F)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(F, DeclarationKind.Class, F)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, F)
               parseMetadataStar({)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -70,7 +70,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -113,7 +113,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -147,7 +147,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -172,7 +172,7 @@ parseUnit(class)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
-                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'ComplexTypeParamOrArgInfo')
+                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'ComplexTypeParamOrArgInfo', false)
                               ensureIdentifier(new, constructorReference)
                                 listener: handleIdentifier(Set, constructorReference)
                               listener: beginConstructorReference(Set)
@@ -197,7 +197,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -222,7 +222,7 @@ parseUnit(class)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
-                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'NoTypeParamOrArg')
+                            parseConstructorReference(new, ConstructorReferenceContext.New, Instance of 'NoTypeParamOrArg', false)
                               ensureIdentifier(new, constructorReference)
                                 listener: handleIdentifier(Set, constructorReference)
                               listener: beginConstructorReference(Set)
@@ -239,7 +239,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -288,7 +288,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -328,7 +328,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)
@@ -377,7 +377,7 @@ parseUnit(class)
                 listener: endClassFields(null, null, null, null, null, final, 1, final, ;)
               listener: endMember()
             notEofOrValue(}, final)
-            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, F)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, F)
               parseMetadataStar(;)
                 listener: beginMetadataStar(final)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.expect

@@ -26,7 +26,7 @@ beginCompilationUnit(class)
       handleNoType(>)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(foo)

pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect

@@ -27,15 +27,15 @@ parseUnit(UnmatchedToken(())
             parseClassExtendsOpt(>)
               listener: handleNoType(>)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(>)
+            parseClassWithClauseOpt(>)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(>)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(>)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(>, DeclarationKind.Class, Foo)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, foo)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
               parseMetadataStar({)
                 listener: beginMetadataStar(foo)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_46346.dart.expect

@@ -231,7 +231,7 @@ beginCompilationUnit(class)
       handleNoType(abstract)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -247,7 +247,7 @@ beginCompilationUnit(class)
       handleNoType(as)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -263,7 +263,7 @@ beginCompilationUnit(class)
       handleNoType(assert)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -278,7 +278,7 @@ beginCompilationUnit(class)
       handleNoType(async)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -293,7 +293,7 @@ beginCompilationUnit(class)
       handleNoType(await)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -309,7 +309,7 @@ beginCompilationUnit(class)
       handleNoType(break)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -325,7 +325,7 @@ beginCompilationUnit(class)
       handleNoType(case)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -341,7 +341,7 @@ beginCompilationUnit(class)
       handleNoType(catch)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -357,7 +357,7 @@ beginCompilationUnit(class)
       handleNoType(class)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -373,7 +373,7 @@ beginCompilationUnit(class)
       handleNoType(const)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -389,7 +389,7 @@ beginCompilationUnit(class)
       handleNoType(continue)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -405,7 +405,7 @@ beginCompilationUnit(class)
       handleNoType(covariant)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -421,7 +421,7 @@ beginCompilationUnit(class)
       handleNoType(default)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -437,7 +437,7 @@ beginCompilationUnit(class)
       handleNoType(deferred)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -453,7 +453,7 @@ beginCompilationUnit(class)
       handleNoType(do)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -469,7 +469,7 @@ beginCompilationUnit(class)
       handleNoType(dynamic)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -485,7 +485,7 @@ beginCompilationUnit(class)
       handleNoType(else)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -501,7 +501,7 @@ beginCompilationUnit(class)
       handleNoType(enum)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -517,7 +517,7 @@ beginCompilationUnit(class)
       handleNoType(export)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -533,7 +533,7 @@ beginCompilationUnit(class)
       handleNoType(extends)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -549,7 +549,7 @@ beginCompilationUnit(class)
       handleNoType(extension)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -565,7 +565,7 @@ beginCompilationUnit(class)
       handleNoType(external)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -581,7 +581,7 @@ beginCompilationUnit(class)
       handleNoType(factory)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -597,7 +597,7 @@ beginCompilationUnit(class)
       handleNoType(false)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -613,7 +613,7 @@ beginCompilationUnit(class)
       handleNoType(final)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -629,7 +629,7 @@ beginCompilationUnit(class)
       handleNoType(finally)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -645,7 +645,7 @@ beginCompilationUnit(class)
       handleNoType(for)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -660,7 +660,7 @@ beginCompilationUnit(class)
       handleNoType(Function)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -676,7 +676,7 @@ beginCompilationUnit(class)
       handleNoType(get)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -691,7 +691,7 @@ beginCompilationUnit(class)
       handleNoType(hide)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -707,7 +707,7 @@ beginCompilationUnit(class)
       handleNoType(if)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -723,7 +723,7 @@ beginCompilationUnit(class)
       handleNoType(implements)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -739,7 +739,7 @@ beginCompilationUnit(class)
       handleNoType(import)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -755,7 +755,7 @@ beginCompilationUnit(class)
       handleNoType(in)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -770,7 +770,7 @@ beginCompilationUnit(class)
       handleNoType(inout)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -786,7 +786,7 @@ beginCompilationUnit(class)
       handleNoType(interface)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -802,7 +802,7 @@ beginCompilationUnit(class)
       handleNoType(is)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -818,7 +818,7 @@ beginCompilationUnit(class)
       handleNoType(late)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -834,7 +834,7 @@ beginCompilationUnit(class)
       handleNoType(library)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -850,7 +850,7 @@ beginCompilationUnit(class)
       handleNoType(mixin)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -865,7 +865,7 @@ beginCompilationUnit(class)
       handleNoType(native)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -881,7 +881,7 @@ beginCompilationUnit(class)
       handleNoType(new)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -897,7 +897,7 @@ beginCompilationUnit(class)
       handleNoType(null)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -912,7 +912,7 @@ beginCompilationUnit(class)
       handleNoType(of)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -927,7 +927,7 @@ beginCompilationUnit(class)
       handleNoType(on)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -943,7 +943,7 @@ beginCompilationUnit(class)
       handleNoType(operator)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -958,7 +958,7 @@ beginCompilationUnit(class)
       handleNoType(out)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -974,7 +974,7 @@ beginCompilationUnit(class)
       handleNoType(part)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -989,7 +989,7 @@ beginCompilationUnit(class)
       handleNoType(patch)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1005,7 +1005,7 @@ beginCompilationUnit(class)
       handleNoType(required)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1021,7 +1021,7 @@ beginCompilationUnit(class)
       handleNoType(rethrow)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1037,7 +1037,7 @@ beginCompilationUnit(class)
       handleNoType(return)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1053,7 +1053,7 @@ beginCompilationUnit(class)
       handleNoType(set)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1068,7 +1068,7 @@ beginCompilationUnit(class)
       handleNoType(show)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1083,7 +1083,7 @@ beginCompilationUnit(class)
       handleNoType(source)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1099,7 +1099,7 @@ beginCompilationUnit(class)
       handleNoType(static)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1115,7 +1115,7 @@ beginCompilationUnit(class)
       handleNoType(super)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1131,7 +1131,7 @@ beginCompilationUnit(class)
       handleNoType(switch)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1146,7 +1146,7 @@ beginCompilationUnit(class)
       handleNoType(sync)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1162,7 +1162,7 @@ beginCompilationUnit(class)
       handleNoType(this)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1178,7 +1178,7 @@ beginCompilationUnit(class)
       handleNoType(throw)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1194,7 +1194,7 @@ beginCompilationUnit(class)
       handleNoType(true)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1210,7 +1210,7 @@ beginCompilationUnit(class)
       handleNoType(try)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1226,7 +1226,7 @@ beginCompilationUnit(class)
       handleNoType(typedef)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1242,7 +1242,7 @@ beginCompilationUnit(class)
       handleNoType(var)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1258,7 +1258,7 @@ beginCompilationUnit(class)
       handleNoType(void)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1274,7 +1274,7 @@ beginCompilationUnit(class)
       handleNoType(while)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1290,7 +1290,7 @@ beginCompilationUnit(class)
       handleNoType(with)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
@@ -1305,7 +1305,7 @@ beginCompilationUnit(class)
       handleNoType(yield)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
       endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })

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

@@ -21,10 +21,10 @@ parseUnit(class)
             parseClassExtendsOpt(abstract)
               listener: handleNoType(abstract)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(abstract)
+            parseClassWithClauseOpt(abstract)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(abstract)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(abstract)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(abstract, DeclarationKind.Class, abstract)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -51,10 +51,10 @@ parseUnit(class)
             parseClassExtendsOpt(as)
               listener: handleNoType(as)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(as)
+            parseClassWithClauseOpt(as)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(as)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(as)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(as, DeclarationKind.Class, as)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -81,10 +81,10 @@ parseUnit(class)
             parseClassExtendsOpt(assert)
               listener: handleNoType(assert)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(assert)
+            parseClassWithClauseOpt(assert)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(assert)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(assert)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(assert, DeclarationKind.Class, assert)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -109,10 +109,10 @@ parseUnit(class)
             parseClassExtendsOpt(async)
               listener: handleNoType(async)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(async)
+            parseClassWithClauseOpt(async)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(async)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(async)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(async, DeclarationKind.Class, async)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -137,10 +137,10 @@ parseUnit(class)
             parseClassExtendsOpt(await)
               listener: handleNoType(await)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(await)
+            parseClassWithClauseOpt(await)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(await)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(await)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(await, DeclarationKind.Class, await)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -167,10 +167,10 @@ parseUnit(class)
             parseClassExtendsOpt(break)
               listener: handleNoType(break)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(break)
+            parseClassWithClauseOpt(break)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(break)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(break)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(break, DeclarationKind.Class, break)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -197,10 +197,10 @@ parseUnit(class)
             parseClassExtendsOpt(case)
               listener: handleNoType(case)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(case)
+            parseClassWithClauseOpt(case)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(case)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(case)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(case, DeclarationKind.Class, case)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -227,10 +227,10 @@ parseUnit(class)
             parseClassExtendsOpt(catch)
               listener: handleNoType(catch)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(catch)
+            parseClassWithClauseOpt(catch)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(catch)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(catch)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(catch, DeclarationKind.Class, catch)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -257,10 +257,10 @@ parseUnit(class)
             parseClassExtendsOpt(class)
               listener: handleNoType(class)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(class)
+            parseClassWithClauseOpt(class)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(class)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(class)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(class, DeclarationKind.Class, class)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -287,10 +287,10 @@ parseUnit(class)
             parseClassExtendsOpt(const)
               listener: handleNoType(const)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(const)
+            parseClassWithClauseOpt(const)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(const)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(const)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(const, DeclarationKind.Class, const)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -317,10 +317,10 @@ parseUnit(class)
             parseClassExtendsOpt(continue)
               listener: handleNoType(continue)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(continue)
+            parseClassWithClauseOpt(continue)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(continue)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(continue)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(continue, DeclarationKind.Class, continue)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -347,10 +347,10 @@ parseUnit(class)
             parseClassExtendsOpt(covariant)
               listener: handleNoType(covariant)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(covariant)
+            parseClassWithClauseOpt(covariant)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(covariant)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(covariant)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(covariant, DeclarationKind.Class, covariant)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -377,10 +377,10 @@ parseUnit(class)
             parseClassExtendsOpt(default)
               listener: handleNoType(default)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(default)
+            parseClassWithClauseOpt(default)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(default)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(default)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(default, DeclarationKind.Class, default)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -407,10 +407,10 @@ parseUnit(class)
             parseClassExtendsOpt(deferred)
               listener: handleNoType(deferred)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(deferred)
+            parseClassWithClauseOpt(deferred)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(deferred)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(deferred)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(deferred, DeclarationKind.Class, deferred)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -437,10 +437,10 @@ parseUnit(class)
             parseClassExtendsOpt(do)
               listener: handleNoType(do)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(do)
+            parseClassWithClauseOpt(do)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(do)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(do)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(do, DeclarationKind.Class, do)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -467,10 +467,10 @@ parseUnit(class)
             parseClassExtendsOpt(dynamic)
               listener: handleNoType(dynamic)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(dynamic)
+            parseClassWithClauseOpt(dynamic)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(dynamic)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(dynamic)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(dynamic, DeclarationKind.Class, dynamic)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -497,10 +497,10 @@ parseUnit(class)
             parseClassExtendsOpt(else)
               listener: handleNoType(else)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(else)
+            parseClassWithClauseOpt(else)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(else)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(else)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(else, DeclarationKind.Class, else)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -527,10 +527,10 @@ parseUnit(class)
             parseClassExtendsOpt(enum)
               listener: handleNoType(enum)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(enum)
+            parseClassWithClauseOpt(enum)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(enum)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(enum)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(enum, DeclarationKind.Class, enum)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -557,10 +557,10 @@ parseUnit(class)
             parseClassExtendsOpt(export)
               listener: handleNoType(export)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(export)
+            parseClassWithClauseOpt(export)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(export)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(export)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(export, DeclarationKind.Class, export)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -587,10 +587,10 @@ parseUnit(class)
             parseClassExtendsOpt(extends)
               listener: handleNoType(extends)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(extends)
+            parseClassWithClauseOpt(extends)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(extends)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(extends)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(extends, DeclarationKind.Class, extends)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -617,10 +617,10 @@ parseUnit(class)
             parseClassExtendsOpt(extension)
               listener: handleNoType(extension)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(extension)
+            parseClassWithClauseOpt(extension)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(extension)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(extension)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(extension, DeclarationKind.Class, extension)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -647,10 +647,10 @@ parseUnit(class)
             parseClassExtendsOpt(external)
               listener: handleNoType(external)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(external)
+            parseClassWithClauseOpt(external)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(external)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(external)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(external, DeclarationKind.Class, external)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -677,10 +677,10 @@ parseUnit(class)
             parseClassExtendsOpt(factory)
               listener: handleNoType(factory)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(factory)
+            parseClassWithClauseOpt(factory)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(factory)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(factory)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(factory, DeclarationKind.Class, factory)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -707,10 +707,10 @@ parseUnit(class)
             parseClassExtendsOpt(false)
               listener: handleNoType(false)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(false)
+            parseClassWithClauseOpt(false)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(false)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(false)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(false, DeclarationKind.Class, false)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -737,10 +737,10 @@ parseUnit(class)
             parseClassExtendsOpt(final)
               listener: handleNoType(final)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(final)
+            parseClassWithClauseOpt(final)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(final)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(final)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(final, DeclarationKind.Class, final)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -767,10 +767,10 @@ parseUnit(class)
             parseClassExtendsOpt(finally)
               listener: handleNoType(finally)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(finally)
+            parseClassWithClauseOpt(finally)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(finally)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(finally)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(finally, DeclarationKind.Class, finally)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -797,10 +797,10 @@ parseUnit(class)
             parseClassExtendsOpt(for)
               listener: handleNoType(for)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(for)
+            parseClassWithClauseOpt(for)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(for)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(for)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(for, DeclarationKind.Class, for)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -825,10 +825,10 @@ parseUnit(class)
             parseClassExtendsOpt(Function)
               listener: handleNoType(Function)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(Function)
+            parseClassWithClauseOpt(Function)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(Function)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(Function)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(Function, DeclarationKind.Class, Function)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -855,10 +855,10 @@ parseUnit(class)
             parseClassExtendsOpt(get)
               listener: handleNoType(get)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(get)
+            parseClassWithClauseOpt(get)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(get)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(get)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(get, DeclarationKind.Class, get)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -883,10 +883,10 @@ parseUnit(class)
             parseClassExtendsOpt(hide)
               listener: handleNoType(hide)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(hide)
+            parseClassWithClauseOpt(hide)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(hide)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(hide)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(hide, DeclarationKind.Class, hide)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -913,10 +913,10 @@ parseUnit(class)
             parseClassExtendsOpt(if)
               listener: handleNoType(if)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(if)
+            parseClassWithClauseOpt(if)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(if)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(if)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(if, DeclarationKind.Class, if)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -943,10 +943,10 @@ parseUnit(class)
             parseClassExtendsOpt(implements)
               listener: handleNoType(implements)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(implements)
+            parseClassWithClauseOpt(implements)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(implements)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(implements)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(implements, DeclarationKind.Class, implements)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -973,10 +973,10 @@ parseUnit(class)
             parseClassExtendsOpt(import)
               listener: handleNoType(import)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(import)
+            parseClassWithClauseOpt(import)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(import)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(import)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(import, DeclarationKind.Class, import)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1003,10 +1003,10 @@ parseUnit(class)
             parseClassExtendsOpt(in)
               listener: handleNoType(in)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(in)
+            parseClassWithClauseOpt(in)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(in)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(in)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(in, DeclarationKind.Class, in)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1031,10 +1031,10 @@ parseUnit(class)
             parseClassExtendsOpt(inout)
               listener: handleNoType(inout)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(inout)
+            parseClassWithClauseOpt(inout)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(inout)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(inout)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(inout, DeclarationKind.Class, inout)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1061,10 +1061,10 @@ parseUnit(class)
             parseClassExtendsOpt(interface)
               listener: handleNoType(interface)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(interface)
+            parseClassWithClauseOpt(interface)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(interface)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(interface)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(interface, DeclarationKind.Class, interface)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1091,10 +1091,10 @@ parseUnit(class)
             parseClassExtendsOpt(is)
               listener: handleNoType(is)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(is)
+            parseClassWithClauseOpt(is)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(is)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(is)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(is, DeclarationKind.Class, is)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1121,10 +1121,10 @@ parseUnit(class)
             parseClassExtendsOpt(late)
               listener: handleNoType(late)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(late)
+            parseClassWithClauseOpt(late)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(late)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(late)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(late, DeclarationKind.Class, late)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1151,10 +1151,10 @@ parseUnit(class)
             parseClassExtendsOpt(library)
               listener: handleNoType(library)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(library)
+            parseClassWithClauseOpt(library)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(library)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(library)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(library, DeclarationKind.Class, library)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1181,10 +1181,10 @@ parseUnit(class)
             parseClassExtendsOpt(mixin)
               listener: handleNoType(mixin)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(mixin)
+            parseClassWithClauseOpt(mixin)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(mixin)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(mixin)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(mixin, DeclarationKind.Class, mixin)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1209,10 +1209,10 @@ parseUnit(class)
             parseClassExtendsOpt(native)
               listener: handleNoType(native)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(native)
+            parseClassWithClauseOpt(native)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(native)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(native)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(native, DeclarationKind.Class, native)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1239,10 +1239,10 @@ parseUnit(class)
             parseClassExtendsOpt(new)
               listener: handleNoType(new)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(new)
+            parseClassWithClauseOpt(new)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(new)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(new)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(new, DeclarationKind.Class, new)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1269,10 +1269,10 @@ parseUnit(class)
             parseClassExtendsOpt(null)
               listener: handleNoType(null)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(null)
+            parseClassWithClauseOpt(null)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(null)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(null)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(null, DeclarationKind.Class, null)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1297,10 +1297,10 @@ parseUnit(class)
             parseClassExtendsOpt(of)
               listener: handleNoType(of)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(of)
+            parseClassWithClauseOpt(of)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(of)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(of)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(of, DeclarationKind.Class, of)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1325,10 +1325,10 @@ parseUnit(class)
             parseClassExtendsOpt(on)
               listener: handleNoType(on)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(on)
+            parseClassWithClauseOpt(on)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(on)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(on)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(on, DeclarationKind.Class, on)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1355,10 +1355,10 @@ parseUnit(class)
             parseClassExtendsOpt(operator)
               listener: handleNoType(operator)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(operator)
+            parseClassWithClauseOpt(operator)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(operator)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(operator)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(operator, DeclarationKind.Class, operator)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1383,10 +1383,10 @@ parseUnit(class)
             parseClassExtendsOpt(out)
               listener: handleNoType(out)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(out)
+            parseClassWithClauseOpt(out)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(out)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(out)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(out, DeclarationKind.Class, out)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1413,10 +1413,10 @@ parseUnit(class)
             parseClassExtendsOpt(part)
               listener: handleNoType(part)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(part)
+            parseClassWithClauseOpt(part)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(part)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(part)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(part, DeclarationKind.Class, part)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1441,10 +1441,10 @@ parseUnit(class)
             parseClassExtendsOpt(patch)
               listener: handleNoType(patch)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(patch)
+            parseClassWithClauseOpt(patch)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(patch)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(patch)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(patch, DeclarationKind.Class, patch)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1471,10 +1471,10 @@ parseUnit(class)
             parseClassExtendsOpt(required)
               listener: handleNoType(required)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(required)
+            parseClassWithClauseOpt(required)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(required)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(required)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(required, DeclarationKind.Class, required)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1501,10 +1501,10 @@ parseUnit(class)
             parseClassExtendsOpt(rethrow)
               listener: handleNoType(rethrow)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(rethrow)
+            parseClassWithClauseOpt(rethrow)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(rethrow)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(rethrow)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(rethrow, DeclarationKind.Class, rethrow)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1531,10 +1531,10 @@ parseUnit(class)
             parseClassExtendsOpt(return)
               listener: handleNoType(return)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(return)
+            parseClassWithClauseOpt(return)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(return)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(return)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(return, DeclarationKind.Class, return)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1561,10 +1561,10 @@ parseUnit(class)
             parseClassExtendsOpt(set)
               listener: handleNoType(set)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(set)
+            parseClassWithClauseOpt(set)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(set)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(set)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(set, DeclarationKind.Class, set)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1589,10 +1589,10 @@ parseUnit(class)
             parseClassExtendsOpt(show)
               listener: handleNoType(show)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(show)
+            parseClassWithClauseOpt(show)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(show)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(show)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(show, DeclarationKind.Class, show)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1617,10 +1617,10 @@ parseUnit(class)
             parseClassExtendsOpt(source)
               listener: handleNoType(source)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(source)
+            parseClassWithClauseOpt(source)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(source)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(source)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(source, DeclarationKind.Class, source)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1647,10 +1647,10 @@ parseUnit(class)
             parseClassExtendsOpt(static)
               listener: handleNoType(static)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(static)
+            parseClassWithClauseOpt(static)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(static)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(static)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(static, DeclarationKind.Class, static)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1677,10 +1677,10 @@ parseUnit(class)
             parseClassExtendsOpt(super)
               listener: handleNoType(super)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(super)
+            parseClassWithClauseOpt(super)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(super)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(super)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(super, DeclarationKind.Class, super)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1707,10 +1707,10 @@ parseUnit(class)
             parseClassExtendsOpt(switch)
               listener: handleNoType(switch)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(switch)
+            parseClassWithClauseOpt(switch)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(switch)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(switch)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(switch, DeclarationKind.Class, switch)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1735,10 +1735,10 @@ parseUnit(class)
             parseClassExtendsOpt(sync)
               listener: handleNoType(sync)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(sync)
+            parseClassWithClauseOpt(sync)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(sync)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(sync)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(sync, DeclarationKind.Class, sync)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1765,10 +1765,10 @@ parseUnit(class)
             parseClassExtendsOpt(this)
               listener: handleNoType(this)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(this)
+            parseClassWithClauseOpt(this)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(this)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(this)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(this, DeclarationKind.Class, this)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1795,10 +1795,10 @@ parseUnit(class)
             parseClassExtendsOpt(throw)
               listener: handleNoType(throw)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(throw)
+            parseClassWithClauseOpt(throw)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(throw)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(throw)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(throw, DeclarationKind.Class, throw)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1825,10 +1825,10 @@ parseUnit(class)
             parseClassExtendsOpt(true)
               listener: handleNoType(true)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(true)
+            parseClassWithClauseOpt(true)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(true)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(true)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(true, DeclarationKind.Class, true)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1855,10 +1855,10 @@ parseUnit(class)
             parseClassExtendsOpt(try)
               listener: handleNoType(try)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(try)
+            parseClassWithClauseOpt(try)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(try)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(try)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(try, DeclarationKind.Class, try)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1885,10 +1885,10 @@ parseUnit(class)
             parseClassExtendsOpt(typedef)
               listener: handleNoType(typedef)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(typedef)
+            parseClassWithClauseOpt(typedef)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(typedef)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(typedef)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(typedef, DeclarationKind.Class, typedef)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1915,10 +1915,10 @@ parseUnit(class)
             parseClassExtendsOpt(var)
               listener: handleNoType(var)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(var)
+            parseClassWithClauseOpt(var)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(var)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(var)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(var, DeclarationKind.Class, var)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1945,10 +1945,10 @@ parseUnit(class)
             parseClassExtendsOpt(void)
               listener: handleNoType(void)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(void)
+            parseClassWithClauseOpt(void)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(void)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(void)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(void, DeclarationKind.Class, void)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -1975,10 +1975,10 @@ parseUnit(class)
             parseClassExtendsOpt(while)
               listener: handleNoType(while)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(while)
+            parseClassWithClauseOpt(while)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(while)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(while)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(while, DeclarationKind.Class, while)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -2005,10 +2005,10 @@ parseUnit(class)
             parseClassExtendsOpt(with)
               listener: handleNoType(with)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(with)
+            parseClassWithClauseOpt(with)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(with)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(with)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(with, DeclarationKind.Class, with)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
@@ -2033,10 +2033,10 @@ parseUnit(class)
             parseClassExtendsOpt(yield)
               listener: handleNoType(yield)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(yield)
+            parseClassWithClauseOpt(yield)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(yield)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(yield)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(yield, DeclarationKind.Class, yield)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)

pkg/front_end/parser_testcases/error_recovery/issue_46346_prime_2.dart.expect

@@ -24,12 +24,12 @@ beginCompilationUnit(class)
       handleNoType()
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       handleNoType()
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleRecoverClassHeader()
       handleRecoverableError(Message[ExpectedClassOrMixinBody, A class declaration must have a body, even if it is empty., Try adding an empty body., {string: class declaration}], , )
       // WARNING: Reporting at eof for .

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

@@ -24,24 +24,24 @@ parseUnit(class)
             parseClassExtendsOpt()
               listener: handleNoType()
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt()
+            parseClassWithClauseOpt()
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt()
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt()
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassHeaderRecovery(, class, class)
             parseClassHeaderOpt(, class, class)
               parseClassExtendsOpt()
-              parseWithClauseOpt()
-              parseClassOrMixinImplementsOpt()
+              parseClassWithClauseOpt()
+              parseClassOrMixinOrEnumImplementsOpt()
             skipUnexpectedTokenOpt(, [extends, with, implements, {])
             parseClassExtendsOpt()
               listener: handleNoType()
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt()
+            parseClassWithClauseOpt()
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt()
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt()
+              listener: handleImplements(null, 0)
             listener: handleRecoverClassHeader()
           ensureBlock(, null, class declaration)
             reportRecoverableError(, Message[ExpectedClassOrMixinBody, A class declaration must have a body, even if it is empty., Try adding an empty body., {string: class declaration}])

pkg/front_end/parser_testcases/error_recovery/issue_46505.crash_dart.expect

@@ -34,7 +34,7 @@ beginCompilationUnit(class)
       handleNoType(A)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(Stream)
@@ -71,7 +71,7 @@ beginCompilationUnit(class)
       handleNoType(B)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(List)

pkg/front_end/parser_testcases/error_recovery/issue_46505.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(A)
               listener: handleNoType(A)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(A)
+            parseClassWithClauseOpt(A)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(A)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(A)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, A)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, Stream)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, A)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, A)
               parseMetadataStar({)
                 listener: beginMetadataStar(Stream)
                 listener: endMetadataStar(0)
@@ -86,15 +86,15 @@ parseUnit(class)
             parseClassExtendsOpt(B)
               listener: handleNoType(B)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(B)
+            parseClassWithClauseOpt(B)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(B)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(B)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(B, DeclarationKind.Class, B)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, List)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, B)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, B)
               parseMetadataStar({)
                 listener: beginMetadataStar(List)
                 listener: endMetadataStar(0)

pkg/front_end/parser_testcases/error_recovery/issue_46505_prime_1.crash_dart.expect

@@ -14,7 +14,7 @@ beginCompilationUnit(class)
       handleNoType(A)
       handleClassExtends(null, 1)
       handleClassNoWithClause()
-      handleClassOrMixinImplements(null, 0)
+      handleImplements(null, 0)
       handleClassHeader(class, class, null)
       beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
         beginMetadataStar(Stream)

pkg/front_end/parser_testcases/error_recovery/issue_46505_prime_1.crash_dart.intertwined.expect

@@ -19,15 +19,15 @@ parseUnit(class)
             parseClassExtendsOpt(A)
               listener: handleNoType(A)
               listener: handleClassExtends(null, 1)
-            parseWithClauseOpt(A)
+            parseClassWithClauseOpt(A)
               listener: handleClassNoWithClause()
-            parseClassOrMixinImplementsOpt(A)
-              listener: handleClassOrMixinImplements(null, 0)
+            parseClassOrMixinOrEnumImplementsOpt(A)
+              listener: handleImplements(null, 0)
             listener: handleClassHeader(class, class, null)
           parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, A)
             listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
             notEofOrValue(}, Stream)
-            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, A)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, A)
               parseMetadataStar({)
                 listener: beginMetadataStar(Stream)
                 listener: endMetadataStar(0)