Transfer parser updates of CL449821 into this CL

Specification proposal:
https://github.com/dart-lang/language/blob/main/working/0260-anonymous-methods/feature-specification.md.

Change-Id: I57743ec663633a148087c1be36e492e1e45e406e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/464704
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Erik Ernst <[email protected]>

Author: eernstg

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

@@ -700,6 +700,36 @@ Message _withArgumentsExpectedButGot({required String string}) {
 Message _withArgumentsOldExpectedButGot(String string) =>
     _withArgumentsExpectedButGot(string: string);
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+  Message Function(String string, String string2),
+  Message Function({required String string, required String string2})
+>
+codeExpectedButGot2 = const Template(
+  "ExpectedButGot2",
+  withArgumentsOld: _withArgumentsOldExpectedButGot2,
+  withArguments: _withArgumentsExpectedButGot2,
+  pseudoSharedCode: PseudoSharedCode.expectedToken,
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsExpectedButGot2({
+  required String string,
+  required String string2,
+}) {
+  var string_0 = conversions.validateString(string);
+  var string2_0 = conversions.validateString(string2);
+  return new Message(
+    codeExpectedButGot2,
+    problemMessage: """Expected '${string_0}' or '${string2_0}' before this.""",
+    arguments: {'string': string, 'string2': string2},
+  );
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsOldExpectedButGot2(String string, String string2) =>
+    _withArgumentsExpectedButGot2(string: string, string2: string2);
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const MessageCode codeExpectedCatchClauseBody = const MessageCode(
   "ExpectedCatchClauseBody",

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

@@ -13,6 +13,11 @@ class ForwardingListener implements Listener {
 
   ForwardingListener([this.listener]);
 
+  @override
+  void beginAnonymousMethodInvocation(Token token) {
+    listener?.beginAnonymousMethodInvocation(token);
+  }
+
   @override
   void beginArguments(Token token) {
     listener?.beginArguments(token);
@@ -1497,6 +1502,26 @@ class ForwardingListener implements Listener {
     listener?.handleAssignmentExpression(token, endToken);
   }
 
+  @override
+  void endAnonymousMethodInvocation(
+    Token beginToken,
+    Token? functionDefinition,
+    Token endToken, {
+    required bool isExpression,
+  }) {
+    listener?.endAnonymousMethodInvocation(
+      beginToken,
+      functionDefinition,
+      endToken,
+      isExpression: isExpression,
+    );
+  }
+
+  @override
+  void handleImplicitFormalParameters(Token token) {
+    listener?.handleImplicitFormalParameters(token);
+  }
+
   @override
   void handleAsyncModifier(Token? asyncToken, Token? starToken) {
     listener?.handleAsyncModifier(asyncToken, starToken);

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

@@ -1733,6 +1733,29 @@ abstract class Listener implements UnescapeErrorListener {
     logEvent("AssignmentExpression");
   }
 
+  void beginAnonymousMethodInvocation(Token token) {}
+
+  /// Called after the parser has consumed an anonymous method invocation.
+  /// Substructures:
+  /// - The target of the invocation.
+  /// - A formal parameter list (can be implicit, see
+  ///   [handleImplicitFormalParameters]).
+  /// - The body of the anonymous method (either an expression or a block).
+  void endAnonymousMethodInvocation(
+    Token beginToken,
+    Token? functionDefinition,
+    Token endToken, {
+    required bool isExpression,
+  }) {
+    logEvent("AnonymousMethodInvocation");
+  }
+
+  /// Called when an anonymous method invocation does not have
+  /// an explicit formal parameter list.
+  void handleImplicitFormalParameters(Token token) {
+    logEvent("ImplicitFormalParameters");
+  }
+
   /// Called when the parser encounters a binary operator, in between the LHS
   /// and RHS subexpressions.
   ///

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

@@ -23,6 +23,9 @@ enum MemberKind {
   /// A local function.
   Local,
 
+  /// An anonymous method.
+  AnonymousMethod,
+
   /// A non-static method in a class (including constructors).
   NonStaticMethod,
 

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

@@ -215,6 +215,7 @@ class ModifierContext {
     switch (memberKind) {
       case MemberKind.StaticMethod:
       case MemberKind.TopLevelMethod:
+      case MemberKind.AnonymousMethod:
         reportExtraneousModifier(this.covariantToken);
       case MemberKind.ExtensionNonStaticMethod:
       case MemberKind.ExtensionStaticMethod:

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

@@ -331,6 +331,9 @@ class Parser {
   /// `true` if the 'private-named-parameters' feature is enabled.
   final bool _isPrivateNamedParametersEnabled;
 
+  /// `true` if the 'anonymous-methods' feature is enabled.
+  final bool _isAnonymousMethodsFeatureEnabled;
+
   /// Indicates whether the last pattern parsed is allowed inside unary
   /// patterns.  This is set by [parsePrimaryPattern] and [parsePattern].
   ///
@@ -357,7 +360,9 @@ class Parser {
        _isPrimaryConstructorsFeatureEnabled = experimentalFeatures
            .isExperimentEnabled(ExperimentalFlag.primaryConstructors),
        _isPrivateNamedParametersEnabled = experimentalFeatures
-           .isExperimentEnabled(ExperimentalFlag.privateNamedParameters);
+           .isExperimentEnabled(ExperimentalFlag.privateNamedParameters),
+       _isAnonymousMethodsFeatureEnabled = experimentalFeatures
+           .isExperimentEnabled(ExperimentalFlag.anonymousMethods);
 
   /// Executes [callback]; however if `this` is the `TestParser` (from
   /// `pkg/front_end/test/parser_test_parser.dart`) then no output is printed
@@ -2007,6 +2012,7 @@ class Parser {
       case MemberKind.FunctionTypedParameter:
       case MemberKind.GeneralizedFunctionType:
       case MemberKind.Local:
+      case MemberKind.AnonymousMethod:
       case MemberKind.NonStaticField:
       case MemberKind.StaticField:
       case MemberKind.TopLevelField:
@@ -2079,6 +2085,7 @@ class Parser {
             case MemberKind.FunctionTypedParameter:
             case MemberKind.GeneralizedFunctionType:
             case MemberKind.Local:
+            case MemberKind.AnonymousMethod:
             case MemberKind.NonStaticMethod:
             case MemberKind.NonStaticField:
             case MemberKind.StaticField:
@@ -7012,49 +7019,55 @@ class Parser {
       } else if (tokenLevel == SELECTOR_PRECEDENCE) {
         if (identical(type, TokenType.PERIOD) ||
             identical(type, TokenType.QUESTION_PERIOD)) {
-          // Left associative, so we recurse at the next higher precedence
-          // level. However, SELECTOR_PRECEDENCE is the highest level, so we
-          // should just call [parseUnaryExpression] directly. However, a
-          // unary expression isn't legal after a period, so we call
-          // [parsePrimary] instead.
           Token dot = token.next!;
-          token = parsePrimary(
-            dot,
-            IdentifierContext.expressionContinuation,
-            constantPatternContext,
-          );
-
-          if (isDotShorthand) {
-            listener.handleDotShorthandHead(dot);
-            isDotShorthand = false;
+          Token afterDot = dot.next!;
+          // TODO(eernst): Call reportExperimentNotEnabled to guide user when
+          // `_beginsAnonymousMethod(afterDot)`, but experiment disabled.
+          if (_isAnonymousMethodsFeatureEnabled &&
+              _beginsAnonymousMethod(afterDot)) {
+            token = _parseAnonymousMethod(dot, afterDot);
           } else {
-            listener.handleDotAccess(
-              operator,
-              token,
-              /* isNullAware = */ identical(type, TokenType.QUESTION_PERIOD),
+            // Left associative, so we recurse at the next higher precedence
+            // level. However, SELECTOR_PRECEDENCE is the highest level, so we
+            // should just call [parseUnaryExpression] directly. However, a
+            // unary expression isn't legal after a period, so we call
+            // [parsePrimary] instead.
+            token = parsePrimary(
+              dot,
+              IdentifierContext.expressionContinuation,
+              constantPatternContext,
             );
-          }
-
-          Token bangToken = token;
-          if (token.next!.isA(TokenType.BANG)) {
-            bangToken = token.next!;
-          }
-          typeArg = computeMethodTypeArguments(bangToken);
-          if (typeArg != noTypeParamOrArg) {
-            // For example e.f<T>(c), where token is before '<'.
-            if (bangToken.isA(TokenType.BANG)) {
-              listener.handleNonNullAssertExpression(bangToken);
+            if (isDotShorthand) {
+              listener.handleDotShorthandHead(dot);
+              isDotShorthand = false;
+            } else {
+              listener.handleDotAccess(
+                operator,
+                token,
+                /* isNullAware = */ identical(type, TokenType.QUESTION_PERIOD),
+              );
             }
-            token = typeArg.parseArguments(bangToken, this);
-            if (!token.next!.isA(TokenType.OPEN_PAREN)) {
-              if (constantPatternContext != ConstantPatternContext.none) {
-                reportRecoverableError(
-                  bangToken.next!,
-                  codes.codeInvalidConstantPatternGeneric,
-                );
+            Token bangToken = token;
+            if (token.next!.isA(TokenType.BANG)) {
+              bangToken = token.next!;
+            }
+            typeArg = computeMethodTypeArguments(bangToken);
+            if (typeArg != noTypeParamOrArg) {
+              // For example e.f<T>(c), where token is before '<'.
+              if (bangToken.isA(TokenType.BANG)) {
+                listener.handleNonNullAssertExpression(bangToken);
+              }
+              token = typeArg.parseArguments(bangToken, this);
+              if (!token.next!.isA(TokenType.OPEN_PAREN)) {
+                if (constantPatternContext != ConstantPatternContext.none) {
+                  reportRecoverableError(
+                    bangToken.next!,
+                    codes.codeInvalidConstantPatternGeneric,
+                  );
+                }
+                listener.handleTypeArgumentApplication(bangToken.next!);
+                typeArg = noTypeParamOrArg;
               }
-              listener.handleTypeArgumentApplication(bangToken.next!);
-              typeArg = noTypeParamOrArg;
             }
           }
         } else if (identical(type, TokenType.OPEN_PAREN) ||
@@ -7191,6 +7204,84 @@ class Parser {
     return token;
   }
 
+  /// Can the next input be an anonymous method?
+  ///
+  /// Used during `_parsePrecedenceExpressionLoop` and
+  /// `parseCascadeExpression`.
+  ///
+  /// Should only be invoked in a situation where the input before
+  /// [token] is a period or two periods, or a question mark followed by
+  /// one or two periods. Returns true if [token] shows that the next
+  /// construct to parse can only be an anonymous method.
+  bool _beginsAnonymousMethod(Token token) {
+    if (token.isA(TokenType.OPEN_CURLY_BRACKET) ||
+        token.isA(TokenType.FUNCTION)) {
+      return true;
+    }
+    if (token.isA(TokenType.OPEN_PAREN)) {
+      Token? matchingParenthesis = token.endGroup;
+      if (matchingParenthesis != null) {
+        Token? afterMatch = matchingParenthesis.next;
+        if (afterMatch != null &&
+            (afterMatch.isA(TokenType.OPEN_CURLY_BRACKET) ||
+                afterMatch.isA(TokenType.FUNCTION))) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /// Parse an anonymous method.
+  ///
+  /// Used during `_parsePrecedenceExpressionLoop` and
+  /// `parseCascadeExpression`.
+  ///
+  /// Should only be invoked in a situation where
+  /// `_beginsAnonymousMethod(afterPunctuation)` has returned true.
+  Token _parseAnonymousMethod(Token punctuation, Token afterPunctuation) {
+    Token currentToken;
+    listener.beginAnonymousMethodInvocation(punctuation);
+    if (afterPunctuation.isA(TokenType.OPEN_PAREN)) {
+      currentToken = parseFormalParameters(
+        punctuation,
+        MemberKind.AnonymousMethod,
+      );
+    } else {
+      listener.handleImplicitFormalParameters(punctuation);
+      currentToken = punctuation;
+    }
+    Token afterParameters = currentToken.next!;
+    Token? functionDefinition = null;
+    final bool isExpression;
+    if (afterParameters.isA(TokenType.OPEN_CURLY_BRACKET)) {
+      isExpression = false;
+      currentToken = parseBlock(currentToken, BlockKind.functionBody);
+    } else if (afterParameters.isA(TokenType.FUNCTION)) {
+      isExpression = true;
+      functionDefinition = afterParameters;
+      currentToken = parseExpressionWithoutCascade(afterParameters);
+    } else {
+      reportRecoverableError(
+        afterParameters,
+        codes.codeExpectedButGot2.withArgumentsOld("{", "=>"),
+      );
+      functionDefinition = rewriter.insertSyntheticToken(
+        currentToken,
+        TokenType.FUNCTION,
+      );
+      isExpression = true;
+      currentToken = parseExpressionWithoutCascade(functionDefinition);
+    }
+    listener.endAnonymousMethodInvocation(
+      punctuation,
+      functionDefinition,
+      currentToken,
+      isExpression: isExpression,
+    );
+    return currentToken;
+  }
+
   /// Attempt a recovery where [token].next is replaced.
   bool _attemptPrecedenceLevelRecovery(
     Token token,
@@ -7361,13 +7452,19 @@ class Parser {
           cascadeOperator.isA(TokenType.QUESTION_PERIOD_PERIOD),
     );
     listener.beginCascade(cascadeOperator);
-    if (token.next!.isA(TokenType.OPEN_SQUARE_BRACKET)) {
+    Token afterDots = token.next!;
+    if (afterDots.isA(TokenType.OPEN_SQUARE_BRACKET)) {
       token = parseArgumentOrIndexStar(
         token,
         noTypeParamOrArg,
         /* checkedNullAware = */ false,
       );
+    } else if (_isAnonymousMethodsFeatureEnabled &&
+        _beginsAnonymousMethod(afterDots)) {
+      token = _parseAnonymousMethod(cascadeOperator, afterDots);
     } else {
+      // TODO(eernst): Call `reportExperimentNotEnabled` to guide user when
+      // `_beginsAnonymousMethod(afterDots)`.
       token = parseSend(
         token,
         IdentifierContext.expressionContinuation,
@@ -7388,13 +7485,21 @@ class Parser {
       if (next.isA(TokenType.PERIOD) || next.isA(TokenType.QUESTION_PERIOD)) {
         bool isNullAware = next.isA(TokenType.QUESTION_PERIOD);
         Token period = next;
-        token = parseSend(
-          next,
-          IdentifierContext.expressionContinuation,
-          ConstantPatternContext.none,
-        );
-        next = token.next!;
-        listener.handleDotAccess(period, token, isNullAware);
+        Token afterPeriod = period.next!;
+        // TODO(eernst): Call `reportExperimentNotEnabled` to guide user when
+        // there is a match except for the experiment being disabled.
+        if (_isAnonymousMethodsFeatureEnabled &&
+            _beginsAnonymousMethod(afterPeriod)) {
+          token = _parseAnonymousMethod(period, afterPeriod);
+        } else {
+          token = parseSend(
+            next,
+            IdentifierContext.expressionContinuation,
+            ConstantPatternContext.none,
+          );
+          next = token.next!;
+          listener.handleDotAccess(period, token, isNullAware);
+        }
       } else if (next.isA(TokenType.BANG)) {
         listener.handleNonNullAssertExpression(next);
         token = next;