Remove always-on --harmony-rest-parameters flag

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 1486 matching lines @@
 
   data.Dispose();
   return i::MessageTemplate::FormatMessage(isolate, message, arg_object);
 }
 
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyDefaultParameters,
-  kAllowHarmonyRestParameters,
   kAllowHarmonySloppy,
   kAllowHarmonySloppyLet,
   kAllowHarmonyDestructuring,
   kAllowHarmonyDestructuringAssignment,
   kAllowHarmonyNewTarget,
   kAllowStrongMode,
   kNoLegacyConst
 };
 
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 template <typename Traits>
 void SetParserFlags(i::ParserBase<Traits>* parser,
                     i::EnumSet<ParserFlag> flags) {
   parser->set_allow_lazy(flags.Contains(kAllowLazy));
   parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_default_parameters(
       flags.Contains(kAllowHarmonyDefaultParameters));
-  parser->set_allow_harmony_rest_parameters(
-      flags.Contains(kAllowHarmonyRestParameters));
   parser->set_allow_harmony_sloppy(flags.Contains(kAllowHarmonySloppy));
   parser->set_allow_harmony_sloppy_let(flags.Contains(kAllowHarmonySloppyLet));
   parser->set_allow_harmony_destructuring_bind(
       flags.Contains(kAllowHarmonyDestructuring));
   parser->set_allow_harmony_destructuring_assignment(
       flags.Contains(kAllowHarmonyDestructuringAssignment));
   parser->set_allow_strong_mode(flags.Contains(kAllowStrongMode));
   parser->set_allow_legacy_const(!flags.Contains(kNoLegacyConst));
 }
 
@@ skipping 2137 matching lines @@
     "c++",
     "`c`",
     "`${c}`",
     "`template-head${c}`",
     "`${c}template-tail`",
     "`template-head${c}template-tail`",
     "`${c}template-tail`",
     nullptr
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters};
-  RunParserSyncTest(context_data, assignment_expression_suffix_data, kError,
-                    NULL, 0, always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, assignment_expression_suffix_data, kError);
 }
 
 
 TEST(ErrorsArrowFunctions) {
   // Tests that parser and preparser generate the same kind of errors
   // on invalid arrow function syntax.
   const char* context_data[][2] = {
     {"", ";"},
     {"v = ", ";"},
     {"bar ? (", ") : baz;"},
@@ skipping 171 matching lines @@
     "(x, y = 9, {b}, z = 8, ...a) => {}",
     // TODO(wingo, rossberg): This is not accepted right now.
     // "({a} = {}) => {}",
     // "([x] = []) => {}",
     "({a = 42}) => {}",
     "([x = 0]) => {}",
     NULL
   };
 
   static const ParserFlag always_flags[] = {kAllowHarmonyDefaultParameters,
-                                            kAllowHarmonyRestParameters,
                                             kAllowHarmonyDestructuring};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   static const ParserFlag flags[] = {kAllowLazy};
   // In a context where a concise arrow body is parsed with [~In] variant,
   // ensure that nested expressions can still use the 'in' operator,
   const char* loop_context_data[][2] = {{"for (", "; 0;);"},
                                         {nullptr, nullptr}};
   const char* loop_expr_data[] = {"f => ('key' in {})", nullptr};
@@ skipping 86 matching lines @@
     "(a, yield) => {}",
     "(yield, a) => {}",
     "(yield, ...a) => {}",
     "(a, ...yield) => {}",
     "({yield}) => {}",
     "([yield]) => {}",
     NULL
   };
 
   static const ParserFlag always_flags[] = { kAllowHarmonyDestructuring,
-                                             kAllowHarmonyRestParameters,
                                              kAllowStrongMode};
   RunParserSyncTest(sloppy_function_context_data, arrow_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_function_context_data, arrow_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(generator_context_data, arrow_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
@@ skipping 1306 matching lines @@
     "a, ...   args",
     "...\targs",
     "a, ...\targs",
     "...\r\nargs",
     "a, ...\r\nargs",
     "...\rargs",
     "a, ...\rargs",
     "...\t\n\t\t\n  args",
     "a, ...  \n  \n  args",
     NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters};
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 
 TEST(ParseRestParametersErrors) {
   const char* context_data[][2] = {{"'use strict';(function(",
                                     "){ return args;}(1, [], /regexp/, 'str',"
                                     "function(){});"},
                                    {"(function(", "){ return args;}(1, [],"
                                     "/regexp/, 'str', function(){});"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "...args, b",
       "a, ...args, b",
       "...args,   b",
       "a, ...args,   b",
       "...args,\tb",
       "a,...args\t,b",
       "...args\r\n, b",
       "a, ... args,\r\nb",
       "...args\r,b",
       "a, ... args,\rb",
       "...args\t\n\t\t\n,  b",
       "a, ... args,  \n  \n  b",
       "a, a, ...args",
       "a,\ta, ...args",
       "a,\ra, ...args",
       "a,\na, ...args",
       NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters};
-  RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(RestParameterInSetterMethodError) {
   const char* context_data[][2] = {
       {"'use strict';({ set prop(", ") {} }).prop = 1;"},
       {"'use strict';(class { static set prop(", ") {} }).prop = 1;"},
       {"'use strict';(new (class { set prop(", ") {} })).prop = 1;"},
       {"({ set prop(", ") {} }).prop = 1;"},
       {"(class { static set prop(", ") {} }).prop = 1;"},
       {"(new (class { set prop(", ") {} })).prop = 1;"},
       {nullptr, nullptr}};
   const char* data[] = {"...a", "...arguments", "...eval", nullptr};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters,
-                                            kAllowHarmonySloppy};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
   RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(RestParametersEvalArguments) {
   const char* strict_context_data[][2] =
       {{"'use strict';(function(",
         "){ return;})(1, [], /regexp/, 'str',function(){});"},
        {NULL, NULL}};
   const char* sloppy_context_data[][2] =
       {{"(function(",
         "){ return;})(1, [],/regexp/, 'str', function(){});"},
        {NULL, NULL}};
 
   const char* data[] = {
       "...eval",
       "eval, ...args",
       "...arguments",
       "arguments, ...args",
       NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters};
-
   // Fail in strict mode
-  RunParserSyncTest(strict_context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(strict_context_data, data, kError);
 
   // OK in sloppy mode
-  RunParserSyncTest(sloppy_context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(sloppy_context_data, data, kSuccess);
 }
 
 
 TEST(RestParametersDuplicateEvalArguments) {
   const char* context_data[][2] =
       {{"'use strict';(function(",
         "){ return;})(1, [], /regexp/, 'str',function(){});"},
        {"(function(",
         "){ return;})(1, [],/regexp/, 'str', function(){});"},
        {NULL, NULL}};
 
   const char* data[] = {
       "eval, ...eval",
       "eval, eval, ...args",
       "arguments, ...arguments",
       "arguments, arguments, ...args",
       NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters};
-
   // In strict mode, the error is using "eval" or "arguments" as parameter names
   // In sloppy mode, the error is that eval / arguments are duplicated
-  RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(SpreadCall) {
   const char* context_data[][2] = {{"function fn() { 'use strict';} fn(", ");"},
                                    {"function fn() {} fn(", ");"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "...([1, 2, 3])", "...'123', ...'456'", "...new Set([1, 2, 3]), 4",
@@ skipping 813 matching lines @@
       "constructor() { \"use strong\" }",
       "constructor(...rest) { \"use strong\" }",
       "foo() {} constructor() { \"use strong\" }",
       "foo(...rest) { \"use strict\" } constructor() { \"use strong\" }", NULL};
 
   const char* success_data[] = {
       "constructor() { \"use strict\" }", "foo() { \"use strong\" }",
       "foo() { \"use strong\" } constructor() {}", NULL};
 
   static const ParserFlag always_flags[] = {
-      kAllowHarmonyRestParameters, kAllowHarmonySloppy, kAllowHarmonySloppyLet,
-      kAllowStrongMode};
+      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kAllowStrongMode};
 
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(StrongUndefinedLocal) {
   const char* context_data[][2] = {{"", ""}, {NULL}};
@@ skipping 911 matching lines @@
     "var f = {x,y} => {};",
     nullptr};
   // clang-format on
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(DestructuringDisallowPatternsInRestParams) {
   i::FLAG_harmony_destructuring_bind = true;
-  i::FLAG_harmony_rest_parameters = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyRestParameters,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {{"'use strict';", ""},
                                    {"function outer() { 'use strict';", "}"},
                                    {"", ""},
                                    {"function outer() { ", "}"},
                                    {nullptr, nullptr}};
 
   // clang-format off
   const char* error_data[] = {
     "function(...{}) {}",
     "function(...{x}) {}",
@@ skipping 341 matching lines @@
       "a, b, c = 1",
       "...args",
       "a, b, ...rest",
       "[a, b, ...rest]",
       "{ bindingPattern = {} }",
       "{ initializedBindingPattern } = { initializedBindingPattern: true }",
       NULL};
 
   static const ParserFlag always_flags[] = {
       kAllowHarmonyDefaultParameters, kAllowHarmonyDestructuring,
-      kAllowHarmonyRestParameters, kAllowHarmonySloppy, kAllowStrongMode};
+      kAllowHarmonySloppy, kAllowStrongMode};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(LetSloppyOnly) {
   // clang-format off
   const char* context_data[][2] = {
     {"", ""},
     {"{", "}"},
@@ skipping 208 matching lines @@
 }
 
 
 TEST(MiscSyntaxErrors) {
   const char* context_data[][2] = {
       {"'use strict'", ""}, {"", ""}, {NULL, NULL}};
   const char* error_data[] = {"for (();;) {}", NULL};
 
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, NULL, 0);
 }