Remove destructuring and default arguments runtime flags

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 1485 matching lines @@
     arg_object = isolate->factory()->undefined_value();
   }
 
   data.Dispose();
   return i::MessageTemplate::FormatMessage(isolate, message, arg_object);
 }
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
-  kAllowHarmonyDefaultParameters,
   kAllowHarmonySloppy,
   kAllowHarmonySloppyLet,
-  kAllowHarmonyDestructuring,
-  kAllowHarmonyDestructuringAssignment,
   kAllowHarmonyNewTarget,
   kNoLegacyConst,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyRestrictiveDeclarations,
 };
 
 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_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_legacy_const(!flags.Contains(kNoLegacyConst));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
   parser->set_allow_harmony_restrictive_declarations(
       flags.Contains(kAllowHarmonyRestrictiveDeclarations));
 }
 
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
@@ skipping 797 matching lines @@
     "yield, yield",
     "yield; yield",
     "(yield) ? yield : yield",
     "(yield) \n ? yield : yield",
     // If there is a newline before the next token, we don't look for RHS.
     "yield\nfor (;;) {}",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyDestructuringAssignment};
-  RunParserSyncTest(context_data, statement_data, kSuccess, nullptr, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsYieldGenerator) {
   // clang-format off
   const char* context_data[][2] = {
     { "function * gen() {", "}" },
     { "\"use strict\"; function * gen() {", "}" },
     { NULL, NULL }
   };
@@ skipping 1368 matching lines @@
     "(a, b - c) => {}",
     "\"a\" => {}",
     "(\"a\") => {}",
     "(\"a\", b) => {}",
     "(a, \"b\") => {}",
     "-a => {}",
     "(-a) => {}",
     "(-a, b) => {}",
     "(a, -b) => {}",
     "{} => {}",
-    "({}) => {}",
-    "(a, {}) => {}",
-    "({}, a) => {}",
     "a++ => {}",
     "(a++) => {}",
     "(a++, b) => {}",
     "(a, b++) => {}",
     "[] => {}",
-    "([]) => {}",
-    "(a, []) => {}",
-    "([], a) => {}",
-    "(a = b) => {}",
-    "(a = b, c) => {}",
-    "(a, b = c) => {}",
     "(foo ? bar : baz) => {}",
     "(a, foo ? bar : baz) => {}",
     "(foo ? bar : baz, a) => {}",
     "(a.b, c) => {}",
     "(c, a.b) => {}",
     "(a['b'], c) => {}",
     "(c, a['b']) => {}",
 
     // crbug.com/582626
     "(...rest - a) => b",
@@ skipping 13 matching lines @@
   const char* loop_context_data[][2] = {{"for (", "; 0;);"},
                                         {nullptr, nullptr}};
   const char* loop_expr_data[] = {"f => 'key' in {}", nullptr};
   RunParserSyncTest(loop_context_data, loop_expr_data, kError, flags,
                     arraysize(flags));
 }
 
 
 TEST(NoErrorsArrowFunctions) {
   // Tests that parser and preparser accept valid arrow functions syntax.
+  // clang-format off
   const char* context_data[][2] = {
     {"", ";"},
     {"bar ? (", ") : baz;"},
     {"bar ? baz : (", ");"},
     {"bar, ", ";"},
     {"", ", bar;"},
     {NULL, NULL}
   };
 
   const char* statement_data[] = {
@@ skipping 25 matching lines @@
     "(a, b, (c, d) => 0)",
     "(a, b) => 0, (c, d) => 1",
     "(a, b => {}, a => a + 1)",
     "((a, b) => {}, (a => a + 1))",
     "(a, (a, (b, c) => 0))",
 
     // Arrow has more precedence, this is the same as: foo ? bar : (baz = {})
     "foo ? bar : baz => {}",
 
     // Arrows with non-simple parameters.
+    "({}) => {}",
+    "(a, {}) => {}",
+    "({}, a) => {}",
+    "([]) => {}",
+    "(a, []) => {}",
+    "([], a) => {}",
+    "(a = b) => {}",
+    "(a = b, c) => {}",
+    "(a, b = c) => {}",
     "({a}) => {}",
     "(x = 9) => {}",
     "(x, y = 9) => {}",
     "(x = 9, y) => {}",
     "(x, y = 9, z) => {}",
     "(x, y = 9, z = 8) => {}",
     "(...a) => {}",
     "(x, ...a) => {}",
     "(x = 9, ...a) => {}",
     "(x, y = 9, ...a) => {}",
     "(x, y = 9, {b}, z = 8, ...a) => {}",
-    // TODO(wingo, rossberg): This is not accepted right now.
-    // "({a} = {}) => {}",
-    // "([x] = []) => {}",
+    "({a} = {}) => {}",
+    "([x] = []) => {}",
     "({a = 42}) => {}",
     "([x = 0]) => {}",
     NULL
   };
+  // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyDefaultParameters,
-                                            kAllowHarmonyDestructuring};
-  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kSuccess);
 
   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};
   RunParserSyncTest(loop_context_data, loop_expr_data, kSuccess, flags,
                     arraysize(flags));
 }
@@ skipping 66 matching lines @@
     "(yield) => {}",
     "(a, yield) => {}",
     "(yield, a) => {}",
     "(yield, ...a) => {}",
     "(a, ...yield) => {}",
     "({yield}) => {}",
     "([yield]) => {}",
     NULL
   };
 
-  static const ParserFlag always_flags[] = { kAllowHarmonyDestructuring };
-  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));
+  RunParserSyncTest(sloppy_function_context_data, arrow_data, kSuccess);
+  RunParserSyncTest(strict_function_context_data, arrow_data, kError);
+  RunParserSyncTest(generator_context_data, arrow_data, kError);
 }
 
 
 TEST(SuperNoErrors) {
   // Tests that parser and preparser accept 'super' keyword in right places.
   const char* context_data[][2] = {
     {"class C { m() { ", "; } }"},
     {"class C { m() { k = ", "; } }"},
     {"class C { m() { foo(", "); } }"},
     {"class C { m() { () => ", "; } }"},
@@ skipping 1406 matching lines @@
                         "...\rargs",
                         "a, ...\rargs",
                         "...\t\n\t\t\n  args",
                         "a, ...  \n  \n  args",
                         "...{ length, 0: a, 1: b}",
                         "...{}",
                         "...[a, b]",
                         "...[]",
                         "...[...[a, b, ...c]]",
                         NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
-  RunParserSyncTest(context_data, data, kSuccess, nullptr, 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}};
@@ skipping 628 matching lines @@
       "(a/*\n*/=> a)(1)",
       "((a)\n=> a)(1)",
       "((a)/*\n*/=> a)(1)",
       "((a, b)\n=> a + b)(1, 2)",
       "((a, b)/*\n*/=> a + b)(1, 2)",
       NULL};
   RunParserSyncTest(context_data, data, kError);
 }
 
 
-static const ParserFlag kAllDestructuringFlags[] = {
-    kAllowHarmonyDestructuring, kAllowHarmonyDestructuringAssignment,
-    kAllowHarmonyDefaultParameters};
-
 TEST(DestructuringPositiveTests) {
-  i::FLAG_harmony_destructuring_bind = true;
-
   const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                    {"var ", " = {};"},
                                    {"'use strict'; const ", " = {};"},
                                    {"function f(", ") {}"},
                                    {"function f(argument1, ", ") {}"},
                                    {"var f = (", ") => {};"},
                                    {"var f = (argument1,", ") => {};"},
                                    {"try {} catch(", ") {}"},
                                    {NULL, NULL}};
 
@@ skipping 30 matching lines @@
     "{var: x = 42}",
     "{[x] : z}",
     "{[1+1] : z}",
     "{[foo()] : z}",
     "{}",
     "[...rest]",
     "[a,b,...rest]",
     "[a,,...rest]",
     NULL};
   // clang-format on
-  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0,
-                    kAllDestructuringFlags, arraysize(kAllDestructuringFlags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 
 TEST(DestructuringNegativeTests) {
-  i::FLAG_harmony_destructuring_bind = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
-
   {  // All modes.
     const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                      {"var ", " = {};"},
                                      {"'use strict'; const ", " = {};"},
                                      {"function f(", ") {}"},
                                      {"function f(argument1, ", ") {}"},
                                      {"var f = (", ") => {};"},
                                      {"var f = ", " => {};"},
                                      {"var f = (argument1,", ") => {};"},
                                      {"try {} catch(", ") {}"},
@@ skipping 64 matching lines @@
         "{ x : 3 }",
         "{ x : 'foo' }",
         "{ x : /foo/ }",
         "{ x : `foo` }",
         "{ get a() {} }",
         "{ set a() {} }",
         "{ method() {} }",
         "{ *method() {} }",
         NULL};
     // clang-format on
-    RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                      arraysize(always_flags));
-    RunParserSyncTest(context_data, data, kError, NULL, 0,
-                      kAllDestructuringFlags,
-                      arraysize(kAllDestructuringFlags));
+    RunParserSyncTest(context_data, data, kError);
   }
 
   {  // All modes.
     const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                      {"var ", " = {};"},
                                      {"'use strict'; const ", " = {};"},
                                      {"function f(", ") {}"},
                                      {"function f(argument1, ", ") {}"},
                                      {"var f = (", ") => {};"},
                                      {"var f = (argument1,", ") => {};"},
                                      {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
         "x => x",
         "() => x",
         NULL};
     // clang-format on
-    RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                      arraysize(always_flags));
-    RunParserSyncTest(context_data, data, kError, NULL, 0,
-                      kAllDestructuringFlags,
-                      arraysize(kAllDestructuringFlags));
+    RunParserSyncTest(context_data, data, kError);
   }
 
   {  // Strict mode.
     const char* context_data[][2] = {
         {"'use strict'; let ", " = {};"},
         {"'use strict'; const ", " = {};"},
         {"'use strict'; function f(", ") {}"},
         {"'use strict'; function f(argument1, ", ") {}"},
         {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
       "[eval]",
       "{ a : arguments }",
       "[public]",
       "{ x : private }",
       NULL};
     // clang-format on
-    RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                      arraysize(always_flags));
-    RunParserSyncTest(context_data, data, kError, NULL, 0,
-                      kAllDestructuringFlags,
-                      arraysize(kAllDestructuringFlags));
+    RunParserSyncTest(context_data, data, kError);
   }
 
   {  // 'yield' in generators.
     const char* context_data[][2] = {
         {"function*() { var ", " = {};"},
         {"function*() { 'use strict'; let ", " = {};"},
         {"function*() { 'use strict'; const ", " = {};"},
         {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
       "yield",
       "[yield]",
       "{ x : yield }",
       NULL};
     // clang-format on
-    RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                      arraysize(always_flags));
-    RunParserSyncTest(context_data, data, kError, NULL, 0,
-                      kAllDestructuringFlags,
-                      arraysize(kAllDestructuringFlags));
+    RunParserSyncTest(context_data, data, kError);
   }
 
   { // Declaration-specific errors
     const char* context_data[][2] = {{"'use strict'; var ", ""},
                                      {"'use strict'; let ", ""},
                                      {"'use strict'; const ", ""},
                                      {"'use strict'; for (var ", ";;) {}"},
                                      {"'use strict'; for (let ", ";;) {}"},
                                      {"'use strict'; for (const ", ";;) {}"},
                                      {"var ", ""},
                                      {"let ", ""},
                                      {"const ", ""},
                                      {"for (var ", ";;) {}"},
                                      {"for (let ", ";;) {}"},
                                      {"for (const ", ";;) {}"},
                                      {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
       "{ a }",
       "[ a ]",
       NULL};
     // clang-format on
-    static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring,
-                                              kAllowHarmonySloppyLet};
+    static const ParserFlag always_flags[] = {kAllowHarmonySloppyLet};
     RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                       arraysize(always_flags));
   }
 }
 
 
 TEST(DestructuringAssignmentPositiveTests) {
   const char* context_data[][2] = {
       {"'use strict'; let x, y, z; (", " = {});"},
       {"var x, y, z; (", " = {});"},
@@ skipping 152 matching lines @@
     "{ x: (foo['bar']) }",
     "[ ...(a) ]",
     "[ ...(foo['bar']) ]",
     "[ ...(foo.bar) ]",
     "[ (y) ]",
     "[ (foo.bar) ]",
     "[ (foo['bar']) ]",
 
     NULL};
   // clang-format on
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyDestructuringAssignment, kAllowHarmonyDestructuring,
-      kAllowHarmonyDefaultParameters};
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 
-  RunParserSyncTest(mixed_assignments_context_data, data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(mixed_assignments_context_data, data, kSuccess);
 
   const char* empty_context_data[][2] = {
       {"'use strict';", ""}, {"", ""}, {NULL, NULL}};
 
   // CoverInitializedName ambiguity handling in various contexts
   const char* ambiguity_data[] = {
       "var foo = { x = 10 } = {};",
       "var foo = { q } = { x = 10 } = {};",
       "var foo; foo = { x = 10 } = {};",
       "var foo; foo = { q } = { x = 10 } = {};",
       "var x; ({ x = 10 } = {});",
       "var q, x; ({ q } = { x = 10 } = {});",
       "var x; [{ x = 10 } = {}]",
       "var x; (true ? { x = true } = {} : { x = false } = {})",
       "var q, x; (q, { x = 10 } = {});",
       "var { x = 10 } = { x = 20 } = {};",
       "var { x = 10 } = (o = { x = 20 } = {});",
       "var x; (({ x = 10 } = { x = 20 } = {}) => x)({})",
       NULL,
   };
-  RunParserSyncTest(empty_context_data, ambiguity_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(empty_context_data, ambiguity_data, kSuccess);
 }
 
 
 TEST(DestructuringAssignmentNegativeTests) {
   const char* context_data[][2] = {
       {"'use strict'; let x, y, z; (", " = {});"},
       {"var x, y, z; (", " = {});"},
       {"'use strict'; let x, y, z; for (x in ", " = {});"},
       {"'use strict'; let x, y, z; for (x of ", " = {});"},
       {"var x, y, z; for (x in ", " = {});"},
@@ skipping 78 matching lines @@
     "[ (...[a]) ]",
     "[ ([a] = []) ]",
     "[ (++y) ]",
     "[ ...(++y) ]",
 
     "[ x += x ]",
     "{ foo: x += x }",
 
     NULL};
   // clang-format on
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyDestructuringAssignment, kAllowHarmonyDestructuring,
-      kAllowHarmonyDefaultParameters};
-  RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 
   const char* empty_context_data[][2] = {
       {"'use strict';", ""}, {"", ""}, {NULL, NULL}};
 
   // CoverInitializedName ambiguity handling in various contexts
   const char* ambiguity_data[] = {
       "var foo = { x = 10 };",
       "var foo = { q } = { x = 10 };",
       "var foo; foo = { x = 10 };",
       "var foo; foo = { q } = { x = 10 };",
       "var x; ({ x = 10 });",
       "var q, x; ({ q } = { x = 10 });",
       "var x; [{ x = 10 }]",
       "var x; (true ? { x = true } : { x = false })",
       "var q, x; (q, { x = 10 });",
       "var { x = 10 } = { x = 20 };",
       "var { x = 10 } = (o = { x = 20 });",
       "var x; (({ x = 10 } = { x = 20 }) => x)({})",
 
       // Not ambiguous, but uses same context data
       "switch([window %= []] = []) { default: }",
 
       NULL,
   };
-  RunParserSyncTest(empty_context_data, ambiguity_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(empty_context_data, ambiguity_data, kError);
 
   // Strict mode errors
   const char* strict_context_data[][2] = {{"'use strict'; (", " = {})"},
                                           {"'use strict'; for (", " of {}) {}"},
                                           {"'use strict'; for (", " in {}) {}"},
                                           {NULL, NULL}};
   const char* strict_data[] = {"{ eval }",
                                "{ arguments }",
                                "{ foo: eval }",
                                "{ foo: arguments }",
@@ skipping 20 matching lines @@
                                "[ (eval) = 0 ]",
                                "[ (arguments) = 0 ]",
                                "[ ...(eval) ]",
                                "[ ...(arguments) ]",
                                "[ ...(eval = 0) ]",
                                "[ ...(arguments = 0) ]",
                                "[ ...(eval) = 0 ]",
                                "[ ...(arguments) = 0 ]",
 
                                NULL};
-  RunParserSyncTest(strict_context_data, strict_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(strict_context_data, strict_data, kError);
 }
 
 
 TEST(DestructuringDisallowPatternsInForVarIn) {
-  i::FLAG_harmony_destructuring_bind = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {
       {"", ""}, {"function f() {", "}"}, {NULL, NULL}};
   // clang-format off
   const char* error_data[] = {
     "for (let x = {} in null);",
     "for (let x = {} of null);",
     NULL};
   // clang-format on
-  RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kError);
 
   // clang-format off
   const char* success_data[] = {
     "for (var x = {} in null);",
     NULL};
   // clang-format on
-  RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, success_data, kSuccess);
 }
 
 
 TEST(DestructuringDuplicateParams) {
-  i::FLAG_harmony_destructuring_bind = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {{"'use strict';", ""},
                                    {"function outer() { 'use strict';", "}"},
                                    {nullptr, nullptr}};
 
 
   // clang-format off
   const char* error_data[] = {
     "function f(x,x){}",
     "function f(x, {x : x}){}",
     "function f(x, {x}){}",
     "function f({x,x}) {}",
     "function f([x,x]) {}",
     "function f(x, [y,{z:x}]) {}",
     "function f([x,{y:x}]) {}",
     // non-simple parameter list causes duplicates to be errors in sloppy mode.
     "function f(x, x, {a}) {}",
     nullptr};
   // clang-format on
-  RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kError);
 }
 
 
 TEST(DestructuringDuplicateParamsSloppy) {
-  i::FLAG_harmony_destructuring_bind = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {
       {"", ""}, {"function outer() {", "}"}, {nullptr, nullptr}};
 
 
   // clang-format off
   const char* error_data[] = {
     // non-simple parameter list causes duplicates to be errors in sloppy mode.
     "function f(x, {x : x}){}",
     "function f(x, {x}){}",
     "function f({x,x}) {}",
     "function f(x, x, {a}) {}",
     nullptr};
   // clang-format on
-  RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kError);
 }
 
 
 TEST(DestructuringDisallowPatternsInSingleParamArrows) {
-  i::FLAG_harmony_destructuring_bind = true;
-  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[] = {
     "var f = {x} => {};",
     "var f = {x,y} => {};",
     nullptr};
   // clang-format on
-  RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kError);
 }
 
 
 TEST(DefaultParametersYieldInInitializers) {
   // clang-format off
   const char* sloppy_function_context_data[][2] = {
     {"(function f(", ") { });"},
     {NULL, NULL}
   };
 
@@ skipping 39 matching lines @@
 
     "{x}=(yield)",
     "[x]=(yield)",
 
     "{x}=f(yield)",
     "[x]=f(yield)",
     NULL
   };
 
   // clang-format on
-  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring,
-                                            kAllowHarmonyDefaultParameters};
 
-  RunParserSyncTest(sloppy_function_context_data, parameter_data, kSuccess,
-                    NULL, 0, always_flags, arraysize(always_flags));
-  RunParserSyncTest(sloppy_arrow_context_data, parameter_data, kSuccess, NULL,
-                    0, always_flags, arraysize(always_flags));
+  RunParserSyncTest(sloppy_function_context_data, parameter_data, kSuccess);
+  RunParserSyncTest(sloppy_arrow_context_data, parameter_data, kSuccess);
 
-  RunParserSyncTest(strict_function_context_data, parameter_data, kError, NULL,
-                    0, always_flags, arraysize(always_flags));
-  RunParserSyncTest(strict_arrow_context_data, parameter_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(strict_function_context_data, parameter_data, kError);
+  RunParserSyncTest(strict_arrow_context_data, parameter_data, kError);
 
-  RunParserSyncTest(generator_context_data, parameter_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(generator_context_data, parameter_data, kError);
 }
 
 
 TEST(SpreadArray) {
   const char* context_data[][2] = {
       {"'use strict';", ""}, {"", ""}, {NULL, NULL}};
 
   // clang-format off
   const char* data[] = {
     "[...a]",
@@ skipping 191 matching lines @@
       "a, b, {c, d, e}",
       "initializer = true",
       "a, b, c = 1",
       "...args",
       "a, b, ...rest",
       "[a, b, ...rest]",
       "{ bindingPattern = {} }",
       "{ initializedBindingPattern } = { initializedBindingPattern: true }",
       NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyDefaultParameters, kAllowHarmonyDestructuring,
-      kAllowHarmonySloppy};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(LetSloppyOnly) {
   // clang-format off
   const char* context_data[][2] = {
     {"", ""},
     {"{", "}"},
@@ skipping 15 matching lines @@
     "for (const let = 1; let < 1; let++) {}",
     "for (const let in {}) {}",
     "for (const [let] = 1; let < 1; let++) {}",
     "for (const [let] in {}) {}",
     "const let",
     "const [let] = []",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
+                                            kAllowHarmonySloppyLet};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 
   // Some things should be rejected even in sloppy mode
   // This addresses BUG(v8:4403).
 
   // clang-format off
   const char* fail_data[] = {
     "let let = 1",
     "for (let let = 1; let < 1; let++) {}",
@@ skipping 16 matching lines @@
     "let l\\u0065t = 1",
     "const l\\u0065t = 1",
     "let [l\\u0065t] = 1",
     "const [l\\u0065t] = 1",
     "for (let l\\u0065t in {}) {}",
     NULL
   };
   // clang-format on
 
   static const ParserFlag fail_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst,
-      kAllowHarmonyDestructuring};
+      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst};
   RunParserSyncTest(context_data, fail_data, kError, NULL, 0, fail_flags,
                     arraysize(fail_flags));
 }
 
 
 TEST(EscapedKeywords) {
   // clang-format off
   const char* sloppy_context_data[][2] = {
     {"", ""},
     {NULL, NULL}
@@ skipping 81 matching lines @@
     "class C { st\\u0061tic set bar() {} }",
 
     // TODO(adamk): These should not be errors in sloppy mode.
     "(y\\u0069eld);",
     "var y\\u0069eld = 1;",
     "var { y\\u0069eld } = {};",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
   RunParserSyncTest(sloppy_context_data, fail_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, fail_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunModuleParserSyncTest(sloppy_context_data, fail_data, kError, NULL, 0,
                           always_flags, arraysize(always_flags));
 
   // clang-format off
   const char* let_data[] = {
     "var l\\u0065t = 1;",
     "l\\u0065t = 1;",
     "(l\\u0065t === 1);",
     NULL
   };
   // clang-format on
 
   RunParserSyncTest(sloppy_context_data, let_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, let_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
-  static const ParserFlag sloppy_let_flags[] = {
-      kAllowHarmonySloppy, kAllowHarmonySloppyLet, kAllowHarmonyDestructuring};
+  static const ParserFlag sloppy_let_flags[] = {kAllowHarmonySloppy,
+                                                kAllowHarmonySloppyLet};
   RunParserSyncTest(sloppy_context_data, let_data, kSuccess, NULL, 0,
                     sloppy_let_flags, arraysize(sloppy_let_flags));
 
   // Non-errors in sloppy mode
   const char* valid_data[] = {"(\\u0069mplements = 1);",
                               "var impl\\u0065ments = 1;",
                               "var { impl\\u0065ments  } = {};",
                               "(\\u0069nterface = 1);",
                               "var int\\u0065rface = 1;",
                               "var { int\\u0065rface  } = {};",
@@ skipping 137 matching lines @@
   RunParserSyncTest(sloppy_context, error_data, kError);
   RunParserSyncTest(sloppy_context, error_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
   RunParserSyncTest(sloppy_context, unrestricted_data, kSuccess);
   RunParserSyncTest(sloppy_context, unrestricted_data, kError, NULL, 0,
                     restrictive_flags, arraysize(restrictive_flags));
   RunParserSyncTest(sloppy_context, sloppy_data, kSuccess);
   RunParserSyncTest(sloppy_context, sloppy_data, kSuccess, restrictive_flags,
                     arraysize(restrictive_flags));
 }