[parser][analyzer][cfe] Add parsing support for super-parameters

Part of #47525

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

Author: chloestefantsova

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

@@ -728,14 +728,22 @@ class ForwardingListener implements Listener {
   @override
   void endFormalParameter(
       Token? thisKeyword,
-      Token? periodAfterThis,
+      Token? superKeyword,
+      Token? periodAfterThisOrSuper,
       Token nameToken,
       Token? initializerStart,
       Token? initializerEnd,
       FormalParameterKind kind,
       MemberKind memberKind) {
-    listener?.endFormalParameter(thisKeyword, periodAfterThis, nameToken,
-        initializerStart, initializerEnd, kind, memberKind);
+    listener?.endFormalParameter(
+        thisKeyword,
+        superKeyword,
+        periodAfterThisOrSuper,
+        nameToken,
+        initializerStart,
+        initializerEnd,
+        kind,
+        memberKind);
   }
 
   @override

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

@@ -363,7 +363,8 @@ class Listener implements UnescapeErrorListener {
 
   void endFormalParameter(
       Token? thisKeyword,
-      Token? periodAfterThis,
+      Token? superKeyword,
+      Token? periodAfterThisOrSuper,
       Token nameToken,
       Token? initializerStart,
       Token? initializerEnd,

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

@@ -1612,35 +1612,41 @@ class Parser {
         parameterKind == FormalParameterKind.optionalNamed;
 
     Token? thisKeyword;
-    Token? periodAfterThis;
+    Token? superKeyword;
+    Token? periodAfterThisOrSuper;
     IdentifierContext nameContext =
         IdentifierContext.formalParameterDeclaration;
 
-    if (!inFunctionType && optional('this', next)) {
+    if (!inFunctionType &&
+        (optional('this', next) || optional('super', next))) {
       Token originalToken = token;
-      thisKeyword = token = next;
+      if (optional('this', next)) {
+        thisKeyword = token = next;
+      } else {
+        superKeyword = token = next;
+      }
       next = token.next!;
       if (!optional('.', next)) {
         if (isOneOf(next, okNextValueInFormalParameter)) {
           // Recover by not parsing as 'this' --- an error will be given
           // later that it's not an allowed identifier.
           token = originalToken;
           next = token.next!;
-          thisKeyword = null;
+          thisKeyword = superKeyword = null;
         } else {
           // Recover from a missing period by inserting one.
           next = rewriteAndRecover(
               token,
               codes.templateExpectedButGot.withArguments('.'),
               new SyntheticToken(TokenType.PERIOD, next.charOffset));
           // These 3 lines are duplicated here and below.
-          periodAfterThis = token = next;
+          periodAfterThisOrSuper = token = next;
           next = token.next!;
           nameContext = IdentifierContext.fieldInitializer;
         }
       } else {
         // These 3 lines are duplicated here and above.
-        periodAfterThis = token = next;
+        periodAfterThisOrSuper = token = next;
         next = token.next!;
         nameContext = IdentifierContext.fieldInitializer;
       }
@@ -1711,8 +1717,8 @@ class Parser {
     }
 
     Token nameToken;
-    if (periodAfterThis != null) {
-      token = periodAfterThis;
+    if (periodAfterThisOrSuper != null) {
+      token = periodAfterThisOrSuper;
     }
     next = token.next!;
     if (inFunctionType &&
@@ -1759,8 +1765,15 @@ class Parser {
     } else {
       listener.handleFormalParameterWithoutValue(next);
     }
-    listener.endFormalParameter(thisKeyword, periodAfterThis, nameToken,
-        initializerStart, initializerEnd, parameterKind, memberKind);
+    listener.endFormalParameter(
+        thisKeyword,
+        superKeyword,
+        periodAfterThisOrSuper,
+        nameToken,
+        initializerStart,
+        initializerEnd,
+        parameterKind,
+        memberKind);
     return token;
   }
 

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

@@ -38,6 +38,9 @@ abstract class Feature {
   /// Feature information for set literals.
   static final set_literals = ExperimentalFeatures.set_literals;
 
+  /// Feature information for super parameters.
+  static final super_parameters = ExperimentalFeatures.super_parameters;
+
   /// Feature information for the triple-shift operator.
   static final triple_shift = ExperimentalFeatures.triple_shift;
 

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

@@ -570,6 +570,8 @@ abstract class AstVisitor<R> {
 
   R? visitSuperExpression(SuperExpression node);
 
+  R? visitSuperFormalParameter(SuperFormalParameter node);
+
   R? visitSwitchCase(SwitchCase node);
 
   R? visitSwitchDefault(SwitchDefault node);
@@ -4059,6 +4061,48 @@ abstract class SuperExpression implements Expression {
   Token get superKeyword;
 }
 
+/// A super-initializer formal parameter.
+///
+///    superFormalParameter ::=
+///        ('final' [TypeAnnotation] | 'const' [TypeAnnotation] | 'var' | [TypeAnnotation])?
+///        'super' '.' [SimpleIdentifier] ([TypeParameterList]? [FormalParameterList])?
+///
+/// Clients may not extend, implement or mix-in this class.
+abstract class SuperFormalParameter implements NormalFormalParameter {
+  @override
+  SimpleIdentifier get identifier;
+
+  /// Return the token representing either the 'final', 'const' or 'var'
+  /// keyword, or `null` if no keyword was used.
+  Token? get keyword;
+
+  /// Return the parameters of the function-typed parameter, or `null` if this
+  /// is not a function-typed field formal parameter.
+  FormalParameterList? get parameters;
+
+  /// Return the token representing the period.
+  Token get period;
+
+  /// If the parameter is function-typed, and has the question mark, then its
+  /// function type is nullable. Having a nullable function type means that the
+  /// parameter can be null.
+  Token? get question;
+
+  /// Return the token representing the 'super' keyword.
+  Token get superKeyword;
+
+  /// Return the declared type of the parameter, or `null` if the parameter does
+  /// not have a declared type.
+  ///
+  /// Note that if this is a function-typed field formal parameter this is the
+  /// return type of the function.
+  TypeAnnotation? get type;
+
+  /// Return the type parameters associated with this method, or `null` if this
+  /// method is not a generic method.
+  TypeParameterList? get typeParameters;
+}
+
 /// A case in a switch statement.
 ///
 ///    switchCase ::=

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

@@ -872,6 +872,26 @@ abstract class AstFactory {
   /// Returns a newly created super expression.
   SuperExpression superExpression(Token superKeyword);
 
+  /// Returns a newly created super-initializer parameter. Either or both of
+  /// the [comment] and [metadata] can be `null` if the parameter does not have
+  /// the corresponding attribute. The [keyword] can be `null` if there is a
+  /// type. The [type] must be `null` if the keyword is 'var'. The [parameters]
+  /// can be `null` if this is not a function-typed super-initializer
+  /// parameter.
+  SuperFormalParameter superFormalParameter(
+      {Comment? comment,
+      List<Annotation>? metadata,
+      Token? covariantKeyword,
+      Token? requiredKeyword,
+      Token? keyword,
+      TypeAnnotation? type,
+      required Token superKeyword,
+      required Token period,
+      required SimpleIdentifier identifier,
+      TypeParameterList? typeParameters,
+      FormalParameterList? parameters,
+      Token? question});
+
   /// Returns a newly created switch case. The list of [labels] can be `null`
   /// if there are no labels.
   SwitchCase switchCase(List<Label> labels, Token keyword,

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

@@ -560,6 +560,10 @@ class GeneralizingAstVisitor<R> implements AstVisitor<R> {
   @override
   R? visitSuperExpression(SuperExpression node) => visitExpression(node);
 
+  @override
+  R? visitSuperFormalParameter(SuperFormalParameter node) =>
+      visitNormalFormalParameter(node);
+
   @override
   R? visitSwitchCase(SwitchCase node) => visitSwitchMember(node);
 
@@ -1308,6 +1312,12 @@ class RecursiveAstVisitor<R> implements AstVisitor<R> {
     return null;
   }
 
+  @override
+  R? visitSuperFormalParameter(SuperFormalParameter node) {
+    node.visitChildren(this);
+    return null;
+  }
+
   @override
   R? visitSwitchCase(SwitchCase node) {
     node.visitChildren(this);
@@ -1770,6 +1780,9 @@ class SimpleAstVisitor<R> implements AstVisitor<R> {
   @override
   R? visitSuperExpression(SuperExpression node) => null;
 
+  @override
+  R? visitSuperFormalParameter(SuperFormalParameter node) => null;
+
   @override
   R? visitSwitchCase(SwitchCase node) => null;
 
@@ -2183,6 +2196,9 @@ class ThrowingAstVisitor<R> implements AstVisitor<R> {
   @override
   R? visitSuperExpression(SuperExpression node) => _throw(node);
 
+  @override
+  R? visitSuperFormalParameter(SuperFormalParameter node) => _throw(node);
+
   @override
   R? visitSwitchCase(SwitchCase node) => _throw(node);
 
@@ -3144,6 +3160,14 @@ class TimedAstVisitor<T> implements AstVisitor<T> {
     return result;
   }
 
+  @override
+  T? visitSuperFormalParameter(SuperFormalParameter node) {
+    stopwatch.start();
+    T? result = _baseVisitor.visitSuperFormalParameter(node);
+    stopwatch.stop();
+    return result;
+  }
+
   @override
   T? visitSwitchCase(SwitchCase node) {
     stopwatch.start();
@@ -3667,6 +3691,9 @@ class UnifyingAstVisitor<R> implements AstVisitor<R> {
   @override
   R? visitSuperExpression(SuperExpression node) => visitNode(node);
 
+  @override
+  R? visitSuperFormalParameter(SuperFormalParameter node) => visitNode(node);
+
   @override
   R? visitSwitchCase(SwitchCase node) => visitNode(node);
 

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -83,7 +83,7 @@ import 'package:meta/meta.dart';
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 190;
+  static const int DATA_VERSION = 191;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.