Augment. Parse enum constant augmentations, allow just ';' before methods.

I was unable to update the parser to avoid requirement for ';' at all.
Ideally we should be able to parse:
```
enum E {
  void foo()
}
```

Change-Id: I7edba99454b965407c3fb402642933b3d8d6bb7c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/363106
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -769,8 +769,8 @@ class ForwardingListener implements Listener {
   }
 
   @override
-  void handleEnumElement(Token beginToken) {
-    listener?.handleEnumElement(beginToken);
+  void handleEnumElement(Token beginToken, Token? augmentToken) {
+    listener?.handleEnumElement(beginToken, augmentToken);
   }
 
   @override

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

@@ -403,7 +403,7 @@ class Listener implements UnescapeErrorListener {
   /// Handle the enum element. Substructures:
   /// - Metadata
   /// - Enum value (identifier)
-  void handleEnumElement(Token beginToken) {
+  void handleEnumElement(Token beginToken, Token? augmentToken) {
     logEvent("EnumElement");
   }
 

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

@@ -338,9 +338,15 @@ class Parser {
   /// [parsePrimaryPattern] and [parsePattern].
   bool isLastPatternAllowedInsideUnaryPattern = false;
 
-  Parser(this.listener,
-      {this.useImplicitCreationExpression = true, this.allowPatterns = false})
-      : assert(listener != null); // ignore:unnecessary_null_comparison
+  /// Indicates whether the macros feature is enabled.
+  final bool enableFeatureMacros;
+
+  Parser(
+    this.listener, {
+    this.useImplicitCreationExpression = true,
+    this.allowPatterns = false,
+    this.enableFeatureMacros = false,
+  }) : assert(listener != null); // ignore:unnecessary_null_comparison
 
   /// Executes [callback]; however if `this` is the `TestParser` (from
   /// `pkg/front_end/test/parser_test_parser.dart`) then no output is printed
@@ -2368,7 +2374,7 @@ class Parser {
         Token next = token.next!;
         if (optional('}', next) || optional(';', next)) {
           token = next;
-          if (elementCount == 0) {
+          if (elementCount == 0 && !enableFeatureMacros) {
             reportRecoverableError(token, codes.messageEnumDeclarationEmpty);
           }
           break;
@@ -2566,6 +2572,13 @@ class Parser {
   Token parseEnumElement(Token token) {
     Token beginToken = token;
     token = parseMetadataStar(token);
+
+    Token? augmentToken;
+    if (optional('augment', token.next!)) {
+      augmentToken = token.next!;
+      token = token.next!;
+    }
+
     token = ensureIdentifier(token, IdentifierContext.enumValueDeclaration);
     bool hasTypeArgumentsOrDot = false;
     {
@@ -2600,7 +2613,7 @@ class Parser {
     } else {
       listener.handleNoArguments(token);
     }
-    listener.handleEnumElement(beginToken);
+    listener.handleEnumElement(beginToken, augmentToken);
     return token;
   }
 

pkg/analysis_server/test/src/services/correction/fix/add_enum_constant_test.dart

@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analysis_server/src/services/correction/fix.dart';
-import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -174,10 +173,7 @@ enum E {ONE}
 void f() {
   E.ONE;
 }
-''',
-        errorFilter: (e) =>
-            e.errorCode == CompileTimeErrorCode.UNDEFINED_ENUM_CONSTANT,
-        matchFixMessage: "Add enum constant 'ONE'");
+''');
   }
 
   Future<void> test_unnamed() async {

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

@@ -5509,6 +5509,10 @@ abstract final class EnumConstantDeclaration implements Declaration {
   /// doesn't provide any explicit arguments.
   EnumConstantArguments? get arguments;
 
+  /// The `augment` keyword, or `null` if the keyword was absent.
+  @experimental
+  Token? get augmentKeyword;
+
   /// The constructor that is invoked by this enum constant, or `null` if the
   /// AST structure hasn't been resolved, or if the constructor couldn't be
   /// resolved.
@@ -5523,6 +5527,9 @@ abstract final class EnumConstantDeclaration implements Declaration {
 
 final class EnumConstantDeclarationImpl extends DeclarationImpl
     implements EnumConstantDeclaration {
+  @override
+  final Token? augmentKeyword;
+
   @override
   final Token name;
 
@@ -5542,6 +5549,7 @@ final class EnumConstantDeclarationImpl extends DeclarationImpl
   EnumConstantDeclarationImpl({
     required super.comment,
     required super.metadata,
+    required this.augmentKeyword,
     required this.name,
     required this.arguments,
   }) {
@@ -5552,10 +5560,11 @@ final class EnumConstantDeclarationImpl extends DeclarationImpl
   Token get endToken => arguments?.endToken ?? name;
 
   @override
-  Token get firstTokenAfterCommentAndMetadata => name;
+  Token get firstTokenAfterCommentAndMetadata => augmentKeyword ?? name;
 
   @override
   ChildEntities get _childEntities => super._childEntities
+    ..addToken('augmentKeyword', augmentKeyword)
     ..addToken('name', name)
     ..addNode('arguments', arguments);
 

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

@@ -4062,7 +4062,7 @@ class AstBuilder extends StackListener {
   }
 
   @override
-  void handleEnumElement(Token beginToken) {
+  void handleEnumElement(Token beginToken, Token? augmentToken) {
     debugEvent("EnumElement");
     var tmpArguments = pop() as MethodInvocationImpl?;
     var tmpConstructor = pop() as ConstructorNameImpl?;
@@ -4103,6 +4103,7 @@ class AstBuilder extends StackListener {
       constant = EnumConstantDeclarationImpl(
         comment: constant.documentationComment,
         metadata: constant.metadata,
+        augmentKeyword: augmentToken,
         name: constant.name,
         arguments: EnumConstantArgumentsImpl(
           typeArguments: typeArguments,
@@ -4449,6 +4450,7 @@ class AstBuilder extends StackListener {
         EnumConstantDeclarationImpl(
           comment: comment,
           metadata: metadata,
+          augmentKeyword: null,
           name: token,
           arguments: null,
         ),

pkg/analyzer/lib/src/generated/parser.dart

@@ -38,8 +38,11 @@ class Parser {
           featureSet,
           lineInfo,
         ) {
-    fastaParser = fasta.Parser(astBuilder,
-        allowPatterns: featureSet.isEnabled(Feature.patterns));
+    fastaParser = fasta.Parser(
+      astBuilder,
+      allowPatterns: featureSet.isEnabled(Feature.patterns),
+      enableFeatureMacros: featureSet.isEnabled(Feature.macros),
+    );
     astBuilder.parser = fastaParser;
     astBuilder.allowNativeClause = allowNativeClause;
   }

pkg/analyzer/test/generated/parser_fasta_listener.dart

@@ -1399,9 +1399,9 @@ class ForwardingTestListener extends ForwardingListener {
   }
 
   @override
-  void handleEnumElement(Token beginToken) {
+  void handleEnumElement(Token beginToken, Token? augmentToken) {
     expectIn('Enum');
-    super.handleEnumElement(beginToken);
+    super.handleEnumElement(beginToken, augmentToken);
   }
 
   @override

pkg/analyzer/test/generated/parser_test_base.dart

@@ -395,8 +395,11 @@ class FastaParserTestCase
     ErrorReporter errorReporter = ErrorReporter(listener, source);
     AstBuilder astBuilder = AstBuilder(errorReporter, source.uri, true,
         featureSet!, LineInfo.fromContent(content));
-    fasta.Parser parser = fasta.Parser(astBuilder,
-        allowPatterns: featureSet!.isEnabled(Feature.patterns));
+    fasta.Parser parser = fasta.Parser(
+      astBuilder,
+      allowPatterns: featureSet!.isEnabled(Feature.patterns),
+      enableFeatureMacros: featureSet!.isEnabled(Feature.macros),
+    );
     astBuilder.parser = parser;
     astBuilder.allowNativeClause = allowNativeClause;
     parser.parseUnit(_fastaTokens);

pkg/analyzer/test/src/dart/parser/enum_test.dart

@@ -14,11 +14,37 @@ main() {
 
 @reflectiveTest
 class EnumDeclarationParserTest extends ParserDiagnosticsTest {
-  test_augment() {
+  test_augment_constant_add() {
     var parseResult = parseStringWithErrors(r'''
 augment library 'a.dart';
 
-augment enum E {bar}
+augment enum E {
+  v
+}
+''');
+    parseResult.assertNoErrors();
+
+    var node = parseResult.findNode.singleEnumDeclaration;
+    assertParsedNodeText(node, r'''
+EnumDeclaration
+  augmentKeyword: augment
+  enumKeyword: enum
+  name: E
+  leftBracket: {
+  constants
+    EnumConstantDeclaration
+      name: v
+  rightBracket: }
+''');
+  }
+
+  test_augment_constant_augment_withConstructor() {
+    var parseResult = parseStringWithErrors(r'''
+augment library 'a.dart';
+
+augment enum E {
+  augment v.foo()
+}
 ''');
     parseResult.assertNoErrors();
 
@@ -31,7 +57,114 @@ EnumDeclaration
   leftBracket: {
   constants
     EnumConstantDeclaration
-      name: bar
+      augmentKeyword: augment
+      name: v
+      arguments: EnumConstantArguments
+        constructorSelector: ConstructorSelector
+          period: .
+          name: SimpleIdentifier
+            token: foo
+        argumentList: ArgumentList
+          leftParenthesis: (
+          rightParenthesis: )
+  rightBracket: }
+''');
+  }
+
+  test_augment_noConstants_semicolon_method() {
+    var parseResult = parseStringWithErrors(r'''
+augment library 'a.dart';
+
+augment enum E {;
+  void foo() {}
+}
+''');
+    parseResult.assertNoErrors();
+
+    var node = parseResult.findNode.singleEnumDeclaration;
+    assertParsedNodeText(node, r'''
+EnumDeclaration
+  augmentKeyword: augment
+  enumKeyword: enum
+  name: E
+  leftBracket: {
+  semicolon: ;
+  members
+    MethodDeclaration
+      returnType: NamedType
+        name: void
+      name: foo
+      parameters: FormalParameterList
+        leftParenthesis: (
+        rightParenthesis: )
+      body: BlockFunctionBody
+        block: Block
+          leftBracket: {
+          rightBracket: }
+  rightBracket: }
+''');
+  }
+
+  test_declaration_empty() {
+    var parseResult = parseStringWithErrors(r'''
+enum E {}
+''');
+    parseResult.assertNoErrors();
+
+    var node = parseResult.findNode.singleEnumDeclaration;
+    assertParsedNodeText(node, r'''
+EnumDeclaration
+  enumKeyword: enum
+  name: E
+  leftBracket: {
+  rightBracket: }
+''');
+  }
+
+  test_declaration_noConstants_semicolon() {
+    var parseResult = parseStringWithErrors(r'''
+enum E {;}
+''');
+    parseResult.assertNoErrors();
+
+    var node = parseResult.findNode.singleEnumDeclaration;
+    assertParsedNodeText(node, r'''
+EnumDeclaration
+  enumKeyword: enum
+  name: E
+  leftBracket: {
+  semicolon: ;
+  rightBracket: }
+''');
+  }
+
+  test_declaration_noConstants_semicolon_method() {
+    var parseResult = parseStringWithErrors(r'''
+enum E {;
+  void foo() {}
+}
+''');
+    parseResult.assertNoErrors();
+
+    var node = parseResult.findNode.singleEnumDeclaration;
+    assertParsedNodeText(node, r'''
+EnumDeclaration
+  enumKeyword: enum
+  name: E
+  leftBracket: {
+  semicolon: ;
+  members
+    MethodDeclaration
+      returnType: NamedType
+        name: void
+      name: foo
+      parameters: FormalParameterList
+        leftParenthesis: (
+        rightParenthesis: )
+      body: BlockFunctionBody
+        block: Block
+          leftBracket: {
+          rightBracket: }
   rightBracket: }
 ''');
   }