[parser] Declaring constructors - Parse primary constructor this body.

Added two listener calls `beginPrimaryConstructorBody` and
`endPrimaryConstructorBody` for parsing the `this` body.
No AST implementation has been done, only parsing.

Bug: #61699
Change-Id: I6aaf621bb3e67bfe00efe32de8097ca1e5048afb
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/459901
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>

Author: kallentu

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

@@ -2669,6 +2669,24 @@ class ForwardingListener implements Listener {
   void endConstDotShorthand(Token token) {
     listener?.beginConstDotShorthand(token);
   }
+
+  @override
+  void beginPrimaryConstructorBody(Token token) {
+    listener?.beginPrimaryConstructorBody(token);
+  }
+
+  @override
+  void endPrimaryConstructorBody(
+    Token beginToken,
+    Token? beginInitializers,
+    Token endToken,
+  ) {
+    listener?.endPrimaryConstructorBody(
+      beginToken,
+      beginInitializers,
+      endToken,
+    );
+  }
 }
 
 class NullListener extends ForwardingListener {

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

@@ -356,6 +356,21 @@ abstract class Listener implements UnescapeErrorListener {
     bool forExtensionType,
   ) {}
 
+  void beginPrimaryConstructorBody(Token token) {}
+
+  // Handles the `this` body block for a primary constructor. Substructures:
+  /// - metadata
+  /// - initializers
+  /// - async marker
+  /// - body
+  void endPrimaryConstructorBody(
+    Token beginToken,
+    Token? beginInitializers,
+    Token endToken,
+  ) {
+    logEvent("endPrimaryConstructorBody");
+  }
+
   void beginCombinators(Token token) {}
 
   void endCombinators(int count) {

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

@@ -3715,6 +3715,24 @@ class Parser {
     return token;
   }
 
+  Token parsePrimaryConstructorBody(Token token) {
+    Token beginToken = token;
+    listener.beginPrimaryConstructorBody(token);
+
+    Token? beforeInitializers = token;
+    token = parseInitializersOpt(beforeInitializers);
+
+    token = parseAsyncModifierOpt(token);
+    token = parseFunctionBody(
+      token,
+      /* ofFunctionExpression = */ false,
+      /* allowAbstract = */ inPlainSync,
+    );
+
+    listener.endPrimaryConstructorBody(beginToken, beforeInitializers, token);
+    return token;
+  }
+
   /// Parses an extension type declaration after
   ///
   ///    'extension' 'type'
@@ -5361,6 +5379,22 @@ class Parser {
           return token;
         }
         // Fall through to continue parsing `operator` as an identifier.
+      } else if (identical(value, 'this')) {
+        Token next2 = next.next!;
+        if (next2.isA(TokenType.COLON) ||
+            next2.isA(TokenType.SEMICOLON) ||
+            next2.isA(TokenType.OPEN_CURLY_BRACKET)) {
+          if (!_isDeclaringConstructorsFeatureEnabled) {
+            reportExperimentNotEnabled(
+              ExperimentalFlag.declaringConstructors,
+              next,
+              next,
+            );
+          }
+          token = parsePrimaryConstructorBody(next);
+          listener.endMember();
+          return token;
+        }
       } else if (!next.isIdentifier ||
           (identical(value, 'typedef') &&
               token == beforeStart &&

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

@@ -617,6 +617,11 @@ class AstBuilder extends StackListener {
     debugEvent("PrimaryConstructor");
   }
 
+  @override
+  void beginPrimaryConstructorBody(Token beginToken) {
+    debugEvent("PrimaryConstructorBody");
+  }
+
   @override
   void beginSwitchCaseWhenClause(Token when) {
     debugEvent("PatternSwitchCaseGuard");
@@ -3168,6 +3173,23 @@ class AstBuilder extends StackListener {
     }
   }
 
+  @override
+  void endPrimaryConstructorBody(
+    Token beginToken,
+    Token? beginInitializers,
+    Token endToken,
+  ) {
+    // TODO(declaring-constructors): Implement primary constructor body.
+    // ignore: unused_local_variable
+    var bodyObject = pop();
+    // ignore: unused_local_variable
+    var initializers = (pop() as List<ConstructorInitializerImpl>?) ?? const [];
+    // ignore: unused_local_variable
+    var separator = pop() as Token?;
+    // ignore: unused_local_variable
+    var metadata = pop() as List<AnnotationImpl>?;
+  }
+
   @override
   void endRecordLiteral(Token leftParenthesis, int count, Token? constKeyword) {
     debugEvent("RecordLiteral");

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

@@ -1213,6 +1213,22 @@ class DietListener extends StackListenerImpl {
     _memberScope = outermostScope;
   }
 
+  @override
+  // Coverage-ignore(suite): Not run.
+  void endPrimaryConstructorBody(
+    Token beginToken,
+    Token? beginInitializers,
+    Token endToken,
+  ) {
+    debugEvent("endPrimaryConstructorBody");
+    assert(
+      checkState(beginToken, [/* metadata token */ ValueKinds.TokenOrNull]),
+    );
+    // TODO(declaring-constructors): Implement primary constructor body.
+    pop() as Token?;
+    checkEmpty(beginToken.charOffset);
+  }
+
   @override
   void endExtensionTypeDeclaration(
     Token beginToken,

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

@@ -1960,6 +1960,31 @@ class OutlineBuilder extends StackListenerImpl {
     );
   }
 
+  @override
+  // Coverage-ignore(suite): Not run.
+  void endPrimaryConstructorBody(
+    Token beginToken,
+    Token? beginInitializers,
+    Token endToken,
+  ) {
+    debugEvent("endPrimaryConstructorBody");
+    assert(
+      checkState(beginToken, [
+        ValueKinds.MethodBody,
+        ValueKinds.AsyncModifier,
+        ValueKinds.MetadataListOrNull,
+      ]),
+    );
+
+    // TODO(declaring-constructors): Implement primary constructor body.
+    // ignore: unused_local_variable
+    MethodBody bodyKind = pop() as MethodBody;
+    // ignore: unused_local_variable
+    AsyncMarker asyncModifier = pop() as AsyncMarker;
+    // ignore: unused_local_variable
+    List<MetadataBuilder>? metadata = pop() as List<MetadataBuilder>?;
+  }
+
   @override
   void beginTopLevelMethod(
     Token lastConsumed,

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

@@ -1533,6 +1533,18 @@ extension MemberExtension on MemberEnd {
     if (child is EnumFactoryMethodEnd) return child;
     throw "Not found";
   }
+
+  bool isPrimaryConstructorBody() {
+    ParserAstNode child = children![1];
+    if (child is PrimaryConstructorBodyEnd) return true;
+    return false;
+  }
+
+  PrimaryConstructorBodyEnd getPrimaryConstructorBody() {
+    ParserAstNode child = children![1];
+    if (child is PrimaryConstructorBodyEnd) return child;
+    throw "Not found";
+  }
 }
 
 // Coverage-ignore(suite): Not run.

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

@@ -548,6 +548,30 @@ abstract class AbstractParserAstListener implements Listener {
     seen(data);
   }
 
+  @override
+  void beginPrimaryConstructorBody(Token token) {
+    PrimaryConstructorBodyBegin data = new PrimaryConstructorBodyBegin(
+      ParserAstType.BEGIN,
+      token: token,
+    );
+    seen(data);
+  }
+
+  @override
+  void endPrimaryConstructorBody(
+    Token beginToken,
+    Token? beginInitializers,
+    Token endToken,
+  ) {
+    PrimaryConstructorBodyEnd data = new PrimaryConstructorBodyEnd(
+      ParserAstType.END,
+      beginToken: beginToken,
+      beginInitializers: beginInitializers,
+      endToken: endToken,
+    );
+    seen(data);
+  }
+
   @override
   void beginCombinators(Token token) {
     CombinatorsBegin data = new CombinatorsBegin(
@@ -5082,6 +5106,46 @@ class NoPrimaryConstructorHandle extends ParserAstNode {
   R accept<R>(ParserAstVisitor<R> v) => v.visitNoPrimaryConstructorHandle(this);
 }
 
+class PrimaryConstructorBodyBegin extends ParserAstNode {
+  final Token token;
+
+  PrimaryConstructorBodyBegin(ParserAstType type, {required this.token})
+    : super("PrimaryConstructorBody", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {"token": token};
+
+  @override
+  R accept<R>(ParserAstVisitor<R> v) =>
+      v.visitPrimaryConstructorBodyBegin(this);
+}
+
+class PrimaryConstructorBodyEnd extends ParserAstNode
+    implements BeginAndEndTokenParserAstNode {
+  @override
+  final Token beginToken;
+  final Token? beginInitializers;
+  @override
+  final Token endToken;
+
+  PrimaryConstructorBodyEnd(
+    ParserAstType type, {
+    required this.beginToken,
+    this.beginInitializers,
+    required this.endToken,
+  }) : super("PrimaryConstructorBody", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+    "beginToken": beginToken,
+    "beginInitializers": beginInitializers,
+    "endToken": endToken,
+  };
+
+  @override
+  R accept<R>(ParserAstVisitor<R> v) => v.visitPrimaryConstructorBodyEnd(this);
+}
+
 class CombinatorsBegin extends ParserAstNode {
   final Token token;
 
@@ -11379,6 +11443,8 @@ abstract class ParserAstVisitor<R> {
   R visitPrimaryConstructorBegin(PrimaryConstructorBegin node);
   R visitPrimaryConstructorEnd(PrimaryConstructorEnd node);
   R visitNoPrimaryConstructorHandle(NoPrimaryConstructorHandle node);
+  R visitPrimaryConstructorBodyBegin(PrimaryConstructorBodyBegin node);
+  R visitPrimaryConstructorBodyEnd(PrimaryConstructorBodyEnd node);
   R visitCombinatorsBegin(CombinatorsBegin node);
   R visitCombinatorsEnd(CombinatorsEnd node);
   R visitCompilationUnitBegin(CompilationUnitBegin node);
@@ -11917,6 +11983,14 @@ class RecursiveParserAstVisitor implements ParserAstVisitor<void> {
   void visitNoPrimaryConstructorHandle(NoPrimaryConstructorHandle node) =>
       node.visitChildren(this);
 
+  @override
+  void visitPrimaryConstructorBodyBegin(PrimaryConstructorBodyBegin node) =>
+      node.visitChildren(this);
+
+  @override
+  void visitPrimaryConstructorBodyEnd(PrimaryConstructorBodyEnd node) =>
+      node.visitChildren(this);
+
   @override
   void visitCombinatorsBegin(CombinatorsBegin node) => node.visitChildren(this);
 
@@ -13384,6 +13458,15 @@ class RecursiveParserAstVisitorWithDefaultNodeAsync
     NoPrimaryConstructorHandle node,
   ) => defaultNode(node);
 
+  @override
+  Future<void> visitPrimaryConstructorBodyBegin(
+    PrimaryConstructorBodyBegin node,
+  ) => defaultNode(node);
+
+  @override
+  Future<void> visitPrimaryConstructorBodyEnd(PrimaryConstructorBodyEnd node) =>
+      defaultNode(node);
+
   @override
   Future<void> visitCombinatorsBegin(CombinatorsBegin node) =>
       defaultNode(node);

pkg/front_end/parser_testcases/declaring_constructors/class_primary_constructor_body.dart

@@ -0,0 +1,15 @@
+class C1() {
+  this {}
+}
+
+class C2() {
+  this : assert(1 > 2) {}
+}
+
+class C3() {
+  this;
+}
+
+class C4() {
+  this : assert(1 > 2);
+}