Enable --harmony-trailing-commas

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1257 matching lines @@
   }
   result[length] = '\0';
   return result;
 }
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyRestrictiveGenerators,
-  kAllowHarmonyTrailingCommas,
   kAllowHarmonyClassFields,
   kAllowHarmonyObjectSpread,
 };
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 void SetGlobalFlags(i::EnumSet<ParserFlag> flags) {
   i::FLAG_allow_natives_syntax = flags.Contains(kAllowNatives);
   i::FLAG_harmony_function_sent = flags.Contains(kAllowHarmonyFunctionSent);
   i::FLAG_harmony_restrictive_generators =
       flags.Contains(kAllowHarmonyRestrictiveGenerators);
-  i::FLAG_harmony_trailing_commas = flags.Contains(kAllowHarmonyTrailingCommas);
   i::FLAG_harmony_class_fields = flags.Contains(kAllowHarmonyClassFields);
   i::FLAG_harmony_object_spread = flags.Contains(kAllowHarmonyObjectSpread);
 }
 
 void SetParserFlags(i::PreParser* parser, i::EnumSet<ParserFlag> flags) {
   parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
   parser->set_allow_harmony_restrictive_generators(
       flags.Contains(kAllowHarmonyRestrictiveGenerators));
-  parser->set_allow_harmony_trailing_commas(
-      flags.Contains(kAllowHarmonyTrailingCommas));
   parser->set_allow_harmony_class_fields(
       flags.Contains(kAllowHarmonyClassFields));
   parser->set_allow_harmony_object_spread(
       flags.Contains(kAllowHarmonyObjectSpread));
 }
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
                              ParserSyncTestResult result,
                              bool is_module = false,
@@ skipping 7108 matching lines @@
     "(b,c,d,) => {};",
     "a(1,);",
     "a(1,2,3,);",
     "a(...[],);",
     "a(1, 2, ...[],);",
     "a(...[], 2, ...[],);",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyTrailingCommas};
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 TEST(TrailingCommasInParametersErrors) {
   // clang-format off
   const char* context_data[][2] = {
     { "", "" },
     { "'use strict';", "" },
     { "function foo() {", "}" },
     { "function foo() {'use strict';", "}" },
     { NULL, NULL }
@@ skipping 42 matching lines @@
     "(...b,) => {};",
     "(b, c, ...d,) => {};",
     // parenthesized trailing comma without arrow is still an error
     "(,);",
     "(a,);",
     "(a,b,c,);",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyTrailingCommas};
-  RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 TEST(ArgumentsRedeclaration) {
   {
     // clang-format off
     const char* context_data[][2] = {
       { "function f(", ") {}" },
       { NULL, NULL }
     };
     const char* success_data[] = {
@@ skipping 322 matching lines @@
     DCHECK_NOT_NULL(scope);
     DCHECK_NULL(scope->sibling());
     DCHECK(scope->is_function_scope());
     const i::AstRawString* var_name =
         info.ast_value_factory()->GetOneByteString("my_var");
     i::Variable* var = scope->Lookup(var_name);
     CHECK_EQ(inners[i].ctxt_allocate,
              i::ScopeTestHelper::MustAllocateInContext(var));
   }
 }