Parser support for trailing commas (#26647).

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.generated.parser_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
@@ skipping 1198 matching lines @@
   void test_externalSetterWithBody() {
     parse3("parseClassMember", <Object>["C"], "external set x(int value) {}",
         [ParserErrorCode.EXTERNAL_SETTER_WITH_BODY]);
   }
 
   void test_externalTypedef() {
     ParserTestCase.parseCompilationUnit(
         "external typedef F();", [ParserErrorCode.EXTERNAL_TYPEDEF]);
   }
 
+  void test_extraCommaInParameterList() {
+    parseTrailingCommas = true;
+    parse4("parseFormalParameterList", "(int a, , int b)",
+        [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+    parseTrailingCommas = false;
+    parse4("parseFormalParameterList", "(int a, , int b)",
+        [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+  }
+
+  void test_extraCommaTrailingNamedParameterGroup() {
+    parseTrailingCommas = true;
+    parse4("parseFormalParameterList", "({int b},)", [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS
+    ]);
+    parseTrailingCommas = false;
+    parse4("parseFormalParameterList", "({int b},)", [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS
+    ]);
+  }
+
+  void test_extraCommaTrailingPositionalParameterGroup() {
+    parseTrailingCommas = true;
+    parse4("parseFormalParameterList", "([int b],)", [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS
+    ]);
+    parseTrailingCommas = false;
+    parse4("parseFormalParameterList", "([int b],)", [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS
+    ]);
+  }
+
+  void test_extraTrailingCommaInParameterList() {
+    parseTrailingCommas = true;
+    parse4("parseFormalParameterList", "(a,,)",
+        [ParserErrorCode.MISSING_IDENTIFIER]);
+    parseTrailingCommas = false;
+    parse4("parseFormalParameterList", "(a,,)",
+        [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+  }
+
   void test_factoryTopLevelDeclaration_class() {
     ParserTestCase.parseCompilationUnit(
         "factory class C {}", [ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION]);
   }
 
   void test_factoryTopLevelDeclaration_typedef() {
     ParserTestCase.parseCompilationUnit("factory typedef F();",
         [ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION]);
   }
 
@@ skipping 86 matching lines @@
   void test_illegalAssignmentToNonAssignable_postfix_minusMinus_literal() {
     parseExpression(
         "0--", [ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE]);
   }
 
   void test_illegalAssignmentToNonAssignable_postfix_plusPlus_literal() {
     parseExpression(
         "0++", [ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE]);
   }
 
-  void test_illegalAssignmentToNonAssignable_postfix_plusPlus_parethesized() {
+  void test_illegalAssignmentToNonAssignable_postfix_plusPlus_parenthesized() {
     parseExpression(
         "(x)++", [ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE]);
   }
 
   void test_illegalAssignmentToNonAssignable_primarySelectorPostfix() {
     parseExpression(
         "x(y)(z)++", [ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE]);
   }
 
   void test_illegalAssignmentToNonAssignable_superAssigned() {
@@ skipping 372 matching lines @@
   void test_missingIdentifier_inSymbol_first() {
     parse4("parseSymbolLiteral", "#", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_missingIdentifier_number() {
     SimpleIdentifier expression = parse4(
         "parseSimpleIdentifier", "1", [ParserErrorCode.MISSING_IDENTIFIER]);
     expect(expression.isSynthetic, isTrue);
   }
 
+  void test_missingIdentifierForParameterGroup() {
+    parseTrailingCommas = true;
+    parse4("parseFormalParameterList", "(,)",
+        [ParserErrorCode.MISSING_IDENTIFIER]);
+  }
+
   void test_missingKeywordOperator() {
     parse3("parseOperator", <Object>[emptyCommentAndMetadata(), null, null],
         "+(x) {}", [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
   }
 
   void test_missingKeywordOperator_parseClassMember() {
     parse3("parseClassMember", <Object>["C"], "+() {}",
         [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
   }
 
@@ skipping 1042 matching lines @@
    * specific test.
    */
   bool enableGenericMethods = false;
 
   /**
    * Whether generic method comments should be enabled for the test.
    */
   bool enableGenericMethodComments = false;
 
   /**
+   * A flag indicating whether parsing trailing commas in parameter and argument
+   * lists should be enabled for this test.
+   */
+  bool parseTrailingCommas = false;
+
+  /**
    * Return a CommentAndMetadata object with the given values that can be used for testing.
    *
    * @param comment the comment to be wrapped in the object
    * @param annotations the annotations to be wrapped in the object
    * @return a CommentAndMetadata object that can be used for testing
    */
   CommentAndMetadata commentAndMetadata(Comment comment,
       [List<Annotation> annotations]) {
     return new CommentAndMetadata(comment, annotations);
   }
@@ skipping 33 matching lines @@
     Token tokenStream = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     //
     // Parse the source.
     //
     Parser parser = createParser(listener);
     parser.parseAsync = parseAsync;
     parser.parseGenericMethods = enableGenericMethods;
     parser.parseGenericMethodComments = enableGenericMethodComments;
     parser.parseFunctionBodies = parseFunctionBodies;
+    parser.parseTrailingCommas = parseTrailingCommas;
     Object result =
         invokeParserMethodImpl(parser, methodName, objects, tokenStream);
     //
     // Partially test the results.
     //
     if (!listener.hasErrors) {
       expect(result, isNotNull);
     }
     return result;
   }
@@ skipping 1905 matching lines @@
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(3));
   }
 
   void test_parseArgumentList_onlyNamed() {
     ArgumentList argumentList = parse4("parseArgumentList", "(x: x, y: y)");
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(2));
   }
 
+  void test_parseArgumentList_trailing_comma() {
+    parseTrailingCommas = true;
+    ArgumentList argumentList = parse4("parseArgumentList", "(x, y, z,)");
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(3));
+  }
+
   void test_parseAssertStatement() {
     AssertStatement statement = parse4("parseAssertStatement", "assert (x);");
     expect(statement.assertKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.comma, isNull);
     expect(statement.message, isNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
@@ skipping 1162 matching lines @@
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
+  void test_parseClassMember_method_trailing_commas() {
+    parseTrailingCommas = true;
+    MethodDeclaration method =
+        parse("parseClassMember", <Object>["C"], "void f(int x, int y,) {}");
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
   void test_parseClassMember_operator_index() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "int operator [](int i) {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNotNull);
@@ skipping 370 matching lines @@
     expect(reference.identifier.isSynthetic, isTrue);
     expect(reference.identifier.name, "");
     // Should end with EOF token.
     Token nextToken = referenceToken.next;
     expect(nextToken, isNotNull);
     expect(nextToken.type, TokenType.EOF);
   }
 
   void test_parseCommentReferences_notClosed_withIdentifier() {
     DocumentationCommentToken docToken = new DocumentationCommentToken(
-          TokenType.MULTI_LINE_COMMENT, "/** [namePrefix some text", 5);
-    List<CommentReference> references =
-        parse("parseCommentReferences", <Object>[<DocumentationCommentToken>[
-      docToken
-    ]], "")
-        as List<CommentReference>;
+        TokenType.MULTI_LINE_COMMENT, "/** [namePrefix some text", 5);
+    List<CommentReference> references = parse(
+        "parseCommentReferences",
+        <Object>[
+          <DocumentationCommentToken>[docToken]
+        ],
+        "") as List<CommentReference>;
     expect(docToken.references, hasLength(1));
     expect(references, hasLength(1));
     Token referenceToken = docToken.references[0];
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(referenceToken, same(reference.beginToken));
     expect(reference.identifier, isNotNull);
     expect(reference.identifier.isSynthetic, isFalse);
     expect(reference.identifier.name, "namePrefix");
     // Should end with EOF token.
@@ skipping 1424 matching lines @@
   void test_parseFormalParameterList_named_single() {
     FormalParameterList parameterList =
         parse4("parseFormalParameterList", "({A a})");
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
     expect(parameterList.parameters, hasLength(1));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
+  void test_parseFormalParameterList_named_trailing_comma() {
+    parseTrailingCommas = true;
+    FormalParameterList parameterList =
+        parse4("parseFormalParameterList", "(A a, {B b,})");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNotNull);
+    expect(parameterList.parameters, hasLength(2));
+    expect(parameterList.rightDelimiter, isNotNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
   void test_parseFormalParameterList_normal_multiple() {
     FormalParameterList parameterList =
         parse4("parseFormalParameterList", "(A a, B b, C c)");
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNull);
     expect(parameterList.parameters, hasLength(3));
     expect(parameterList.rightDelimiter, isNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
@@ skipping 20 matching lines @@
   void test_parseFormalParameterList_normal_single() {
     FormalParameterList parameterList =
         parse4("parseFormalParameterList", "(A a)");
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNull);
     expect(parameterList.parameters, hasLength(1));
     expect(parameterList.rightDelimiter, isNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
+  void test_parseFormalParameterList_normal_single_trailing_comma() {
+    parseTrailingCommas = true;
+    FormalParameterList parameterList =
+        parse4("parseFormalParameterList", "(A a,)");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNull);
+    expect(parameterList.parameters, hasLength(1));
+    expect(parameterList.rightDelimiter, isNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
   void test_parseFormalParameterList_positional_multiple() {
     FormalParameterList parameterList =
         parse4("parseFormalParameterList", "([A a = null, B b, C c = null])");
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
     expect(parameterList.parameters, hasLength(3));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_positional_single() {
     FormalParameterList parameterList =
         parse4("parseFormalParameterList", "([A a = null])");
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
     expect(parameterList.parameters, hasLength(1));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
+  void test_parseFormalParameterList_positional_trailing_comma() {
+    parseTrailingCommas = true;
+    FormalParameterList parameterList =
+        parse4("parseFormalParameterList", "(A a, [B b,])");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNotNull);
+    expect(parameterList.parameters, hasLength(2));
+    expect(parameterList.rightDelimiter, isNotNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
   void test_parseFormalParameterList_prefixedType() {
     FormalParameterList parameterList =
         parse4("parseFormalParameterList", "(io.File f)");
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNull);
     expect(parameterList.parameters, hasLength(1));
     expect(parameterList.parameters[0].toSource(), 'io.File f');
     expect(parameterList.rightDelimiter, isNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
@@ skipping 3342 matching lines @@
         new Scanner(null, new CharSequenceReader(source), listener);
     Token tokenStream = scanner.tokenize();
     //
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser, methodName, <Object>[tokenStream], tokenStream) as Token;
   }
 }