Add parser support for ... in list patterns.

Bug: #50035
Change-Id: I31c7003fd40a6e074f2561561d2fba49955cc098
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/271565
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

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

@@ -1864,6 +1864,11 @@ class ForwardingListener implements Listener {
     listener?.handleSpreadExpression(spreadToken);
   }
 
+  @override
+  void handleRestPattern(Token dots, {required bool hasSubPattern}) {
+    listener?.handleRestPattern(dots, hasSubPattern: hasSubPattern);
+  }
+
   @override
   void handleStringJuxtaposition(Token startToken, int literalCount) {
     listener?.handleStringJuxtaposition(startToken, literalCount);

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

@@ -370,6 +370,36 @@ bool looksLikeExpressionStart(Token next) =>
     optional('++', next) ||
     optional('--', next);
 
+/// Returns `true` if the given [token] should be treated like the start of a
+/// pattern for the purposes of recovery.
+///
+/// Note: since the syntax for patterns is very similar to that for expressions,
+/// we mostly re-use [looksLikeExpressionStart].
+bool looksLikePatternStart(Token next) =>
+    next.isIdentifier ||
+    next.type == TokenType.DOUBLE ||
+    next.type == TokenType.HASH ||
+    next.type == TokenType.HEXADECIMAL ||
+    next.type == TokenType.IDENTIFIER ||
+    next.type == TokenType.INT ||
+    next.type == TokenType.STRING ||
+    optional('null', next) ||
+    optional('false', next) ||
+    optional('true', next) ||
+    optional('{', next) ||
+    optional('(', next) ||
+    optional('[', next) ||
+    optional('[]', next) ||
+    optional('<', next) ||
+    optional('<=', next) ||
+    optional('>', next) ||
+    optional('>=', next) ||
+    optional('!=', next) ||
+    optional('==', next) ||
+    optional('var', next) ||
+    optional('final', next) ||
+    optional('const', next);
+
 /// Return `true` if the given [token] should be treated like the start of
 /// a new statement for the purposes of recovery.
 bool looksLikeStatementStart(Token token) => isOneOfOrEof(token, const [

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

@@ -1673,6 +1673,13 @@ class Listener implements UnescapeErrorListener {
     logEvent("SpreadExpression");
   }
 
+  /// Called after parsing an element of a list or map pattern that starts with
+  /// `...`.  Substructures:
+  /// - pattern (if hasSubPattern is `true`)
+  void handleRestPattern(Token dots, {required bool hasSubPattern}) {
+    logEvent('RestPattern');
+  }
+
   /// Handle the start of a function typed formal parameter.  Substructures:
   /// - type variables
   void beginFunctionTypedFormalParameter(Token token) {}

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

@@ -75,6 +75,7 @@ import 'identifier_context.dart'
     show
         IdentifierContext,
         looksLikeExpressionStart,
+        looksLikePatternStart,
         okNextValueInFormalParameter;
 
 import 'identifier_context_impl.dart'
@@ -9493,7 +9494,18 @@ class Parser {
         token = next;
         break;
       }
-      token = parsePattern(token, isRefutableContext: isRefutableContext);
+      if (optional('...', next)) {
+        Token dots = next;
+        token = next;
+        next = token.next!;
+        bool hasSubPattern = looksLikePatternStart(next);
+        if (hasSubPattern) {
+          token = parsePattern(token, isRefutableContext: isRefutableContext);
+        }
+        listener.handleRestPattern(dots, hasSubPattern: hasSubPattern);
+      } else {
+        token = parsePattern(token, isRefutableContext: isRefutableContext);
+      }
       next = token.next!;
       ++count;
       if (!optional(',', next)) {

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

@@ -4972,6 +4972,12 @@ class AstBuilder extends StackListener {
         operator: token, operand: pop() as ExpressionImpl));
   }
 
+  @override
+  void handleRestPattern(Token dots, {required bool hasSubPattern}) {
+    var subPattern = hasSubPattern ? pop() as DartPatternImpl : null;
+    push(RestPatternElementImpl(operator: dots, pattern: subPattern));
+  }
+
   @override
   void handleScript(Token token) {
     assert(identical(token.type, TokenType.SCRIPT_TAG));

pkg/analyzer/test/generated/patterns_parser_test.dart

@@ -6608,6 +6608,90 @@ RecordPattern
 ''');
   }
 
+  test_rest_subpatternStartingTokens() {
+    // Test a wide variety of rest subpatterns to make sure the parser properly
+    // identifies each as a subpattern.  (The logic for deciding if a rest
+    // pattern has a subpattern is based on the token that follows the `..`, so
+    // we test every kind of token that can legally follow `...`).  Note that
+    // not all of these are semantically meaningful, but they should all be
+    // parseable.
+    // TODO(paulberry): if support for symbol literal patterns is added (see
+    // https://github.com/dart-lang/language/issues/2636), adjust this test
+    // accordingly.
+    _parse('''
+void f(x) {
+  switch (x) {
+    case [...== null]:
+    case [...!= null]:
+    case [...< 0]:
+    case [...> 0]:
+    case [...<= 0]:
+    case [...>= 0]:
+    case [...0]:
+    case [...0.0]:
+    case [...0x0]:
+    case [...null]:
+    case [...false]:
+    case [...true]:
+    case [...'foo']:
+    case [...x]:
+    case [...const List()]:
+    case [...var x]:
+    case [...final x]:
+    case [...List x]:
+    case [..._]:
+    case [...(_)]:
+    case [...[_]]:
+    case [...[]]:
+    case [...<int>[]]:
+    case [...{}]:
+    case [...List()]:
+      break;
+  }
+}
+''');
+    // No assertions; it's sufficient to make sure the parse succeeds without
+    // errors.
+  }
+
+  test_rest_withoutSubpattern_insideList() {
+    _parse('''
+void f(x) {
+  switch (x) {
+    case [...]:
+      break;
+  }
+}
+''');
+    var node = findNode.singleGuardedPattern.pattern;
+    assertParsedNodeText(node, r'''
+ListPattern
+  leftBracket: [
+  elements
+    RestPatternElement
+  rightBracket: ]
+''');
+  }
+
+  test_rest_withSubpattern_insideList() {
+    _parse('''
+void f(x) {
+  switch (x) {
+    case [...var y]:
+      break;
+  }
+}
+''');
+    var node = findNode.singleGuardedPattern.pattern;
+    assertParsedNodeText(node, r'''
+ListPattern
+  leftBracket: [
+  elements
+    RestPatternElement
+  rightBracket: ]
+''');
+  }
+
   test_variable_bare_insideCast() {
     _parse('''
 void f(x) {

pkg/analyzer/test/src/summary/resolved_ast_printer.dart

@@ -1179,6 +1179,14 @@ class ResolvedAstPrinter extends ThrowingAstVisitor<void> {
     });
   }
 
+  @override
+  void visitRestPatternElement(RestPatternElement node) {
+    _writeln('RestPatternElement');
+    _withIndent(() {
+      _writeNamedChildEntities(node);
+    });
+  }
+
   @override
   void visitReturnStatement(ReturnStatement node) {
     _writeln('ReturnStatement');

pkg/front_end/lib/src/fasta/kernel/macro/annotation_parser.dart

@@ -2091,6 +2091,11 @@ class _MacroListener implements Listener {
     _unsupported();
   }
 
+  @override
+  void handleRestPattern(Token dots, {required bool hasSubPattern}) {
+    _unsupported();
+  }
+
   @override
   void handleSuperExpression(Token token, IdentifierContext context) {
     _unsupported();

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

@@ -2232,6 +2232,13 @@ abstract class AbstractParserAstListener implements Listener {
     seen(data);
   }
 
+  @override
+  void handleRestPattern(Token dots, {required bool hasSubPattern}) {
+    RestPatternHandle data = new RestPatternHandle(ParserAstType.HANDLE,
+        dots: dots, hasSubPattern: hasSubPattern);
+    seen(data);
+  }
+
   @override
   void beginFunctionTypedFormalParameter(Token token) {
     FunctionTypedFormalParameterBegin data =
@@ -6823,6 +6830,21 @@ class SpreadExpressionHandle extends ParserAstNode {
       };
 }
 
+class RestPatternHandle extends ParserAstNode {
+  final Token dots;
+  final bool hasSubPattern;
+
+  RestPatternHandle(ParserAstType type,
+      {required this.dots, required this.hasSubPattern})
+      : super("RestPattern", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "dots": dots,
+        "hasSubPattern": hasSubPattern,
+      };
+}
+
 class FunctionTypedFormalParameterBegin extends ParserAstNode {
   final Token token;
 

pkg/front_end/parser_testcases/patterns/rest_subpatternStartingTokens.dart

@@ -0,0 +1,30 @@
+void f(x) {
+  switch (x) {
+    case [...== null]:
+    case [...!= null]:
+    case [...< 0]:
+    case [...> 0]:
+    case [...<= 0]:
+    case [...>= 0]:
+    case [...0]:
+    case [...0.0]:
+    case [...0x0]:
+    case [...null]:
+    case [...false]:
+    case [...true]:
+    case [...'foo']:
+    case [...x]:
+    case [...const List()]:
+    case [...var x]:
+    case [...final x]:
+    case [...List x]:
+    case [..._]:
+    case [...(_)]:
+    case [...[_]]:
+    case [...[]]:
+    case [...<int>[]]:
+    case [...{}]:
+    case [...List()]:
+      break;
+  }
+}