Remove runtime flags for sloppy mode block scoping features

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 1052 matching lines @@
       i::ScopedVector<char> program(kProgramByteSize + 1);
       i::SNPrintF(program, "%s%s%s", surroundings[j].prefix,
                   source_data[i].body, surroundings[j].suffix);
       i::Handle<i::String> source =
           factory->NewStringFromUtf8(i::CStrVector(program.start()))
               .ToHandleChecked();
       i::Handle<i::Script> script = factory->NewScript(source);
       i::Zone zone(CcTest::i_isolate()->allocator());
       i::ParseInfo info(&zone, script);
       i::Parser parser(&info);
-      parser.set_allow_harmony_sloppy(true);
       info.set_global();
       CHECK(parser.Parse(&info));
       CHECK(i::Rewriter::Rewrite(&info));
       CHECK(i::Scope::Analyze(&info));
       CHECK(info.literal() != NULL);
 
       i::Scope* script_scope = info.literal()->scope();
       CHECK(script_scope->is_script_scope());
       CHECK_EQ(1, script_scope->inner_scopes()->length());
 
@@ skipping 31 matching lines @@
   full_source += "; }";
 
   i::Handle<i::String> source_code =
       factory->NewStringFromUtf8(i::CStrVector(full_source.c_str()))
           .ToHandleChecked();
 
   i::Handle<i::Script> script = factory->NewScript(source_code);
 
   i::ParseInfo info(handles.main_zone(), script);
   i::Parser parser(&info);
-  parser.set_allow_harmony_sloppy(true);
   info.set_global();
   info.set_lazy(false);
   info.set_allow_lazy_parsing(false);
   info.set_toplevel(true);
 
   i::CompilationInfo compilation_info(&info);
   CHECK(i::Compiler::ParseAndAnalyze(&info));
 
   CHECK(info.scope()->declarations()->length() == 1);
   i::FunctionLiteral* fun =
@@ skipping 295 matching lines @@
 
   for (int i = 0; discard_sources[i]; i++) {
     const char* source = discard_sources[i];
     i::Handle<i::String> source_code =
         factory->NewStringFromUtf8(i::CStrVector(source)).ToHandleChecked();
     i::Handle<i::Script> script = factory->NewScript(source_code);
     i::Zone zone(CcTest::i_isolate()->allocator());
     i::ParseInfo info(&zone, script);
     info.set_allow_lazy_parsing();
     i::Parser parser(&info);
-    parser.set_allow_harmony_sloppy(true);
     parser.Parse(&info);
     function = info.literal();
     CHECK_NOT_NULL(function);
     CHECK_NOT_NULL(function->body());
     CHECK_EQ(1, function->body()->length());
     i::FunctionLiteral* inner =
         function->body()->first()->AsExpressionStatement()->expression()->
         AsCall()->expression()->AsFunctionLiteral();
     i::Scope* inner_scope = inner->scope();
     i::FunctionLiteral* fun = nullptr;
@@ skipping 50 matching lines @@
     arg_object = isolate->factory()->undefined_value();
   }
 
   data.Dispose();
   return i::MessageTemplate::FormatMessage(isolate, message, arg_object);
 }
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
-  kAllowHarmonySloppy,
-  kAllowHarmonySloppyLet,
   kAllowHarmonyNewTarget,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyRestrictiveDeclarations,
   kAllowHarmonyExponentiationOperator
 };
 
 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_sloppy(flags.Contains(kAllowHarmonySloppy));
-  parser->set_allow_harmony_sloppy_let(flags.Contains(kAllowHarmonySloppyLet));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
   parser->set_allow_harmony_restrictive_declarations(
       flags.Contains(kAllowHarmonyRestrictiveDeclarations));
   parser->set_allow_harmony_exponentiation_operator(
       flags.Contains(kAllowHarmonyExponentiationOperator));
 }
 
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
@@ skipping 2392 matching lines @@
     "super.x",
     "super[27]",
     "new super.x",
     "new super.x()",
     "new super[27]",
     "new super[27]()",
     "z.super",  // Ok, property lookup.
     NULL
   };
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(SuperErrors) {
   const char* context_data[][2] = {
     {"class C { m() { ", "; } }"},
     {"class C { m() { k = ", "; } }"},
     {"class C { m() { foo(", "); } }"},
     {"class C { m() { () => ", "; } }"},
     {NULL, NULL}
   };
 
   const char* expression_data[] = {
     "super",
     "super = x",
     "y = super",
     "f(super)",
     "new super",
     "new super()",
     "new super(12, 45)",
     "new new super",
     "new new super()",
     "new new super()()",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, expression_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, expression_data, kError);
 }
 
 
 TEST(SuperCall) {
   const char* context_data[][2] = {{"", ""},
                                    {NULL, NULL}};
 
   const char* success_data[] = {
     "class C extends B { constructor() { super(); } }",
     "class C extends B { constructor() { () => super(); } }",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, success_data, kSuccess);
 
   const char* error_data[] = {
     "class C { constructor() { super(); } }",
     "class C { method() { super(); } }",
     "class C { method() { () => super(); } }",
     "class C { *method() { super(); } }",
     "class C { get x() { super(); } }",
     "class C { set x(_) { super(); } }",
     "({ method() { super(); } })",
     "({ *method() { super(); } })",
     "({ get x() { super(); } })",
     "({ set x(_) { super(); } })",
     "({ f: function() { super(); } })",
     "(function() { super(); })",
     "var f = function() { super(); }",
     "({ f: function*() { super(); } })",
     "(function*() { super(); })",
     "var f = function*() { super(); }",
     NULL
   };
 
-  RunParserSyncTest(context_data, error_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kError);
 }
 
 
 TEST(SuperNewNoErrors) {
   const char* context_data[][2] = {
     {"class C { constructor() { ", " } }"},
     {"class C { *method() { ", " } }"},
     {"class C { get x() { ", " } }"},
     {"class C { set x(_) { ", " } }"},
     {"({ method() { ", " } })"},
     {"({ *method() { ", " } })"},
     {"({ get x() { ", " } })"},
     {"({ set x(_) { ", " } })"},
     {NULL, NULL}
   };
 
   const char* expression_data[] = {
     "new super.x;",
     "new super.x();",
     "() => new super.x;",
     "() => new super.x();",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, expression_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, expression_data, kSuccess);
 }
 
 
 TEST(SuperNewErrors) {
   const char* context_data[][2] = {
     {"class C { method() { ", " } }"},
     {"class C { *method() { ", " } }"},
     {"class C { get x() { ", " } }"},
     {"class C { set x(_) { ", " } }"},
     {"({ method() { ", " } })"},
@@ skipping 10 matching lines @@
   };
 
   const char* statement_data[] = {
     "new super;",
     "new super();",
     "() => new super;",
     "() => new super();",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(SuperErrorsNonMethods) {
   // super is only allowed in methods, accessors and constructors.
   const char* context_data[][2] = {
     {"", ";"},
     {"k = ", ";"},
     {"foo(", ");"},
     {"if (", ") {}"},
@@ skipping 17 matching lines @@
     "super.x()",
     "super[27]()",
     "super()",
     "new super.x",
     "new super.x()",
     "new super[27]",
     "new super[27]()",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsMethodDefinition) {
   const char* context_data[][2] = {{"({", "});"},
                                    {"'use strict'; ({", "});"},
                                    {"({*", "});"},
                                    {"'use strict'; ({*", "});"},
                                    {NULL, NULL}};
 
@@ skipping 192 matching lines @@
     "class extends F {}",
     "class name extends F {}",
     "class extends (F, G) {}",
     "class name extends (F, G) {}",
     "class extends class {} {}",
     "class name extends class {} {}",
     "class extends class base {} {}",
     "class name extends class base {} {}",
     NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, class_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_data, kSuccess);
 }
 
 
 TEST(ClassDeclarationNoErrors) {
   const char* context_data[][2] = {{"'use strict'; ", ""},
                                    {"'use strict'; {", "}"},
                                    {"'use strict'; if (true) {", "}"},
                                    {NULL, NULL}};
   const char* statement_data[] = {
     "class name {}",
@@ skipping 53 matching lines @@
     "get st\\u0061tic() {}",
     "set st\\u0061tic(v) {}",
     "static st\\u0061tic() {}",
     "static get st\\u0061tic() {}",
     "static set st\\u0061tic(v) {}",
     "*st\\u0061tic() {}",
     "static *st\\u0061tic() {}",
     NULL};
   // clang-format on
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_body_data, kSuccess);
 }
 
 
 TEST(ClassPropertyNameNoErrors) {
   const char* context_data[][2] = {{"(class {", "() {}});"},
                                    {"(class { get ", "() {}});"},
                                    {"(class { set ", "(v) {}});"},
                                    {"(class { static ", "() {}});"},
                                    {"(class { static get ", "() {}});"},
                                    {"(class { static set ", "(v) {}});"},
@@ skipping 32 matching lines @@
     "if",
     "else",
     "for",
     "while",
     "do",
     "try",
     "catch",
     "finally",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, name_data, kSuccess);
 }
 
 
 TEST(ClassExpressionErrors) {
   const char* context_data[][2] = {{"(", ");"},
                                    {"var C = ", ";"},
                                    {"bar, ", ";"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class",
     "class name",
     "class name extends",
     "class extends",
     "class {",
     "class { m }",
     "class { m; n }",
     "class { m: 1 }",
     "class { m(); n() }",
     "class { get m }",
     "class { get m() }",
     "class { get m() { }",
     "class { set m() {} }",  // Missing required parameter.
     "class { m() {}, n() {} }",  // No commas allowed.
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_data, kError);
 }
 
 
 TEST(ClassDeclarationErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"{", "}"},
                                    {"if (true) {", "}"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class",
@@ skipping 11 matching lines @@
     "class {}",  // Name is required for declaration
     "class extends base {}",
     "class name { *",
     "class name { * }",
     "class name { *; }",
     "class name { *get x() {} }",
     "class name { *set x(_) {} }",
     "class name { *static m() {} }",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_data, kError);
 }
 
 
 TEST(ClassNameErrors) {
   const char* context_data[][2] = {{"class ", "{}"},
                                    {"(class ", "{});"},
                                    {"'use strict'; class ", "{}"},
                                    {"'use strict'; (class ", "{});"},
                                    {NULL, NULL}};
   const char* class_name[] = {
     "arguments",
     "eval",
     "implements",
     "interface",
     "let",
     "package",
     "private",
     "protected",
     "public",
     "static",
     "var",
     "yield",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_name, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_name, kError);
 }
 
 
 TEST(ClassGetterParamNameErrors) {
   const char* context_data[][2] = {
     {"class C { get name(", ") {} }"},
     {"(class { get name(", ") {} });"},
     {"'use strict'; class C { get name(", ") {} }"},
     {"'use strict'; (class { get name(", ") {} })"},
     {NULL, NULL}
   };
 
   const char* class_name[] = {
     "arguments",
     "eval",
     "implements",
     "interface",
     "let",
     "package",
     "private",
     "protected",
     "public",
     "static",
     "var",
     "yield",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_name, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_name, kError);
 }
 
 
 TEST(ClassStaticPrototypeErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "static prototype() {}",
     "static get prototype() {}",
     "static set prototype(_) {}",
     "static *prototype() {}",
     "static 'prototype'() {}",
     "static *'prototype'() {}",
     "static prot\\u006ftype() {}",
     "static 'prot\\u006ftype'() {}",
     "static get 'prot\\u006ftype'() {}",
     "static set 'prot\\u006ftype'(_) {}",
     "static *'prot\\u006ftype'() {}",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_body_data, kError);
 }
 
 
 TEST(ClassSpecialConstructorErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "get constructor() {}",
     "get constructor(_) {}",
     "*constructor() {}",
     "get 'constructor'() {}",
     "*'constructor'() {}",
     "get c\\u006fnstructor() {}",
     "*c\\u006fnstructor() {}",
     "get 'c\\u006fnstructor'() {}",
     "get 'c\\u006fnstructor'(_) {}",
     "*'c\\u006fnstructor'() {}",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_body_data, kError);
 }
 
 
 TEST(ClassConstructorNoErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}",
     "static constructor() {}",
     "static get constructor() {}",
     "static set constructor(_) {}",
     "static *constructor() {}",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_body_data, kSuccess);
 }
 
 
 TEST(ClassMultipleConstructorErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}; constructor() {}",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_body_data, kError);
 }
 
 
 TEST(ClassMultiplePropertyNamesNoErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}; static constructor() {}",
     "m() {}; static m() {}",
     "m() {}; m() {}",
     "static m() {}; static m() {}",
     "get m() {}; set m(_) {}; get m() {}; set m(_) {};",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_body_data, kSuccess);
 }
 
 
 TEST(ClassesAreStrictErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"(", ");"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "class C { method() { with ({}) {} } }",
     "class C extends function() { with ({}) {} } {}",
     "class C { *method() { with ({}) {} } }",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy
-  };
-  RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, class_body_data, kError);
 }
 
 
 TEST(ObjectLiteralPropertyShorthandKeywordsError) {
   const char* context_data[][2] = {{"({", "});"},
                                    {"'use strict'; ({", "});"},
                                    {NULL, NULL}};
 
   const char* name_data[] = {
     "break",
@@ skipping 117 matching lines @@
 TEST(StatementParsingInForIn) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {"for(x in {}, {}) {}", "for(var x in {}, {}) {}",
                         "for(let x in {}, {}) {}", "for(const x in {}, {}) {}",
                         NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kAllowHarmonySloppyLet};
-  RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 
 TEST(ConstParsingInForInError) {
   const char* context_data[][2] = {{"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for(const x,y = 1; ; ) {}",
@@ skipping 87 matching lines @@
       "for (let i, j in {}) {}",
       "for (let i, j in [1, 2, 3]) {}",
       "for (let i, j = 1 in {}) {}",
       "for (let i, j = void 0 in [1, 2, 3]) {}",
 
       "for (const i, j in {}) {}",
       "for (const i, j in [1, 2, 3]) {}",
       "for (const i, j = 1 in {}) {}",
       "for (const i, j = void 0 in [1, 2, 3]) {}",
       NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(ForOfMultipleDeclarationsError) {
   const char* context_data[][2] = {{"", ""},
                                    {"function foo(){", "}"},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for (var i, j of {}) {}",
       "for (var i, j of [1, 2, 3]) {}",
       "for (var i, j = 1 of {}) {}",
       "for (var i, j = void 0 of [1, 2, 3]) {}",
 
       "for (let i, j of {}) {}",
       "for (let i, j of [1, 2, 3]) {}",
       "for (let i, j = 1 of {}) {}",
       "for (let i, j = void 0 of [1, 2, 3]) {}",
 
       "for (const i, j of {}) {}",
       "for (const i, j of [1, 2, 3]) {}",
       "for (const i, j = 1 of {}) {}",
       "for (const i, j = void 0 of [1, 2, 3]) {}",
       NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(ForInNoDeclarationsError) {
   const char* context_data[][2] = {{"", ""},
                                    {"function foo(){", "}"},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for (var in {}) {}",
       "for (const in {}) {}",
       NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(ForOfNoDeclarationsError) {
   const char* context_data[][2] = {{"", ""},
                                    {"function foo(){", "}"},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for (var of [1, 2, 3]) {}",
       "for (const of [1, 2, 3]) {}",
       NULL};
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(ForOfInOperator) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for(x of 'foo' in {}) {}", "for(var x of 'foo' in {}) {}",
       "for(let x of 'foo' in {}) {}", "for(const x of 'foo' in {}) {}", NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kAllowHarmonySloppyLet};
-  RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 
 TEST(ForOfYieldIdentifier) {
   const char* context_data[][2] = {{"", ""}, {NULL, NULL}};
 
   const char* data[] = {"for(x of yield) {}", "for(var x of yield) {}",
                         "for(let x of yield) {}", "for(const x of yield) {}",
                         NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kAllowHarmonySloppyLet};
-  RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 
 TEST(ForOfYieldExpression) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {"function* g() { for(x of yield) {} }",
                         "function* g() { for(var x of yield) {} }",
                         "function* g() { for(let x of yield) {} }",
                         "function* g() { for(const x of yield) {} }", NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kAllowHarmonySloppyLet};
-  RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 
 TEST(ForOfExpressionError) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for(x of [], []) {}", "for(var x of [], []) {}",
       "for(let x of [], []) {}", "for(const x of [], []) {}",
 
       // AssignmentExpression should be validated statically:
       "for(x of { y = 23 }) {}", "for(var x of { y = 23 }) {}",
       "for(let x of { y = 23 }) {}", "for(const x of { y = 23 }) {}", NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kAllowHarmonySloppyLet};
-  RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(InvalidUnicodeEscapes) {
   const char* context_data[][2] = {{"", ""},
                                    {"'use strict';", ""},
                                    {NULL, NULL}};
   const char* data[] = {
     "var foob\\u123r = 0;",
     "var \\u123roo = 0;",
@@ skipping 260 matching lines @@
   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[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(RestParametersEvalArguments) {
+  // clang-format off
   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",
+      // See https://bugs.chromium.org/p/v8/issues/detail?id=4577
+      // "arguments, ...args",
       NULL};
+  // clang-format on
 
   // Fail in strict mode
   RunParserSyncTest(strict_context_data, data, kError);
 
   // OK in sloppy mode
   RunParserSyncTest(sloppy_context_data, data, kSuccess);
 }
 
 
 TEST(RestParametersDuplicateEvalArguments) {
@@ skipping 46 matching lines @@
 
 
 TEST(BadRestSpread) {
   const char* context_data[][2] = {{"function fn() { 'use strict';", "} fn();"},
                                    {"function fn() { ", "} fn();"},
                                    {NULL, NULL}};
   const char* data[] = {"return ...[1,2,3];",     "var ...x = [1,2,3];",
                         "var [...x,] = [1,2,3];", "var [...x, y] = [1,2,3];",
                         "var {...x} = [1,2,3];",  "var { x } = {x: ...[1,2,3]}",
                         NULL};
-  RunParserSyncTest(context_data, data, kError, NULL, 0, NULL, 0);
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(LexicalScopingSloppyMode) {
   const char* context_data[][2] = {
       {"", ""},
       {"function f() {", "}"},
       {"{", "}"},
       {NULL, NULL}};
-  const char* bad_data[] = {
-    "let x = 1;",
-    "for(let x = 1;;){}",
-    "for(let x of []){}",
-    "for(let x in []){}",
-    "class C {}",
-    "class C extends D {}",
-    "(class {})",
-    "(class extends D {})",
-    "(class C {})",
-    "(class C extends D {})",
-    NULL};
-  static const ParserFlag always_false_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, bad_data, kError, NULL, 0, NULL, 0,
-                    always_false_flags, arraysize(always_false_flags));
 
   const char* good_data[] = {
     "let = 1;",
     "for(let = 1;;){}",
     NULL};
-  RunParserSyncTest(context_data, good_data, kSuccess, NULL, 0, NULL, 0,
-                    always_false_flags, arraysize(always_false_flags));
+  RunParserSyncTest(context_data, good_data, kSuccess);
 }
 
 
 TEST(ComputedPropertyName) {
   const char* context_data[][2] = {{"({[", "]: 1});"},
                                    {"({get [", "]() {}});"},
                                    {"({set [", "](_) {}});"},
                                    {"({[", "]() {}});"},
                                    {"({*[", "]() {}});"},
                                    {"(class {get [", "]() {}});"},
                                    {"(class {set [", "](_) {}});"},
                                    {"(class {[", "]() {}});"},
                                    {"(class {*[", "]() {}});"},
                                    {NULL, NULL}};
   const char* error_data[] = {
     "1, 2",
     "var name",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy,
-  };
-  RunParserSyncTest(context_data, error_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kError);
 
   const char* name_data[] = {
     "1",
     "1 + 2",
     "'name'",
     "\"name\"",
     "[]",
     "{}",
     NULL};
 
-  RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, name_data, kSuccess);
 }
 
 
 TEST(ComputedPropertyNameShorthandError) {
   const char* context_data[][2] = {{"({", "});"},
                                    {NULL, NULL}};
   const char* error_data[] = {
     "a: 1, [2]",
     "[1], a: 1",
     NULL};
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonySloppy,
-  };
-  RunParserSyncTest(context_data, error_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kError);
 }
 
 
 TEST(BasicImportExportParsing) {
   // clang-format off
   const char* kSources[] = {
       "export let x = 0;",
       "export var y = 0;",
       "export const z = 0;",
       "export function func() { };",
@@ skipping 625 matching lines @@
                                      {"for (let ", ";;) {}"},
                                      {"for (const ", ";;) {}"},
                                      {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
       "{ a }",
       "[ a ]",
       NULL};
     // clang-format on
-    static const ParserFlag always_flags[] = {kAllowHarmonySloppyLet};
-    RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                      arraysize(always_flags));
+    RunParserSyncTest(context_data, data, kError);
   }
 }
 
 
 TEST(DestructuringAssignmentPositiveTests) {
   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 ", " = {});"},
@@ skipping 565 matching lines @@
     "{ new.target }",
     "() => { new.target }",
     "() => new.target",
     "if (1) { new.target }",
     "if (1) {} else { new.target }",
     "while (0) { new.target }",
     "do { new.target } while (0)",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonyNewTarget,
-    kAllowHarmonySloppy,
-  };
   // clang-format on
 
-  RunParserSyncTest(good_context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
-  RunParserSyncTest(bad_context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(good_context_data, data, kSuccess);
+  RunParserSyncTest(bad_context_data, data, kError);
 }
 
 
 TEST(ConstSloppy) {
   // clang-format off
   const char* context_data[][2] = {
     {"", ""},
     {"{", "}"},
     {NULL, NULL}
   };
 
   const char* data[] = {
     "const x = 1",
     "for (const x = 1; x < 1; x++) {}",
     "for (const x in {}) {}",
     "for (const x of []) {}",
     NULL
   };
   // clang-format on
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 
 TEST(LetSloppy) {
   // clang-format off
   const char* context_data[][2] = {
     {"", ""},
     {"'use strict';", ""},
     {"{", "}"},
     {NULL, NULL}
   };
 
   const char* data[] = {
     "let x",
     "let x = 1",
     "for (let x = 1; x < 1; x++) {}",
     "for (let x in {}) {}",
     "for (let x of []) {}",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kAllowHarmonySloppyLet};
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 }
 
 
 TEST(LanguageModeDirectivesNonSimpleParameterListErrors) {
   // TC39 deemed "use strict" directives to be an error when occurring in the
   // body of a function with non-simple parameter list, on 29/7/2015.
   // https://goo.gl/ueA7Ln
   const char* context_data[][2] = {
       {"function f(", ") { 'use strict'; }"},
       {"function* g(", ") { 'use strict'; }"},
@@ skipping 25 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[] = {kAllowHarmonySloppy};
-  RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kError);
 }
 
 
 TEST(LetSloppyOnly) {
   // clang-format off
   const char* context_data[][2] = {
     {"", ""},
     {"{", "}"},
     {"(function() {", "})()"},
     {NULL, NULL}
   };
 
   const char* data[] = {
     "let",
     "let = 1",
     "for (let = 1; let < 1; let++) {}",
     "for (let in {}) {}",
     "for (var let = 1; let < 1; let++) {}",
     "for (var let in {}) {}",
     "for (var [let] = 1; let < 1; let++) {}",
     "for (var [let] in {}) {}",
     "var let",
     "var [let] = []",
     NULL
   };
   // clang-format on
 
-  static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
-                                            kAllowHarmonySloppyLet};
-  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
-                    arraysize(always_flags));
+  RunParserSyncTest(context_data, data, kSuccess);
 
   // 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++) {}",
     "for (let let in {}) {}",
     "for (let let of []) {}",
@@ skipping 13 matching lines @@
     // Sprinkle in the escaped version too.
     "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};
-  RunParserSyncTest(context_data, fail_data, kError, NULL, 0, fail_flags,
-                    arraysize(fail_flags));
+  RunParserSyncTest(context_data, fail_data, kError);
 }
 
 
 TEST(EscapedKeywords) {
   // clang-format off
   const char* sloppy_context_data[][2] = {
     {"", ""},
     {NULL, NULL}
   };
 
@@ skipping 79 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};
-  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));
+  RunParserSyncTest(sloppy_context_data, fail_data, kError);
+  RunParserSyncTest(strict_context_data, fail_data, kError);
+  RunModuleParserSyncTest(sloppy_context_data, fail_data, kError);
 
   // 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};
-  RunParserSyncTest(sloppy_context_data, let_data, kSuccess, NULL, 0,
-                    sloppy_let_flags, arraysize(sloppy_let_flags));
+  RunParserSyncTest(sloppy_context_data, let_data, kSuccess);
+  RunParserSyncTest(strict_context_data, let_data, kError);
 
   // 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  } = {};",
                               "(p\\u0061ckage = 1);",
                               "var packa\\u0067e = 1;",
                               "var { packa\\u0067e  } = {};",
                               "(p\\u0072ivate = 1);",
                               "var p\\u0072ivate;",
                               "var { p\\u0072ivate } = {};",
                               "(prot\\u0065cted);",
                               "var prot\\u0065cted = 1;",
                               "var { prot\\u0065cted  } = {};",
                               "(publ\\u0069c);",
                               "var publ\\u0069c = 1;",
                               "var { publ\\u0069c } = {};",
                               "(st\\u0061tic);",
                               "var st\\u0061tic = 1;",
                               "var { st\\u0061tic } = {};",
                               NULL};
-  RunParserSyncTest(sloppy_context_data, valid_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
-  RunParserSyncTest(strict_context_data, valid_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
-  RunModuleParserSyncTest(strict_context_data, valid_data, kError, NULL, 0,
-                          always_flags, arraysize(always_flags));
+  RunParserSyncTest(sloppy_context_data, valid_data, kSuccess);
+  RunParserSyncTest(strict_context_data, valid_data, kError);
+  RunModuleParserSyncTest(strict_context_data, valid_data, kError);
 }
 
 
 TEST(MiscSyntaxErrors) {
   // clang-format off
   const char* context_data[][2] = {
     { "'use strict'", "" },
     { "", "" },
     { NULL, NULL }
   };
@@ skipping 244 matching lines @@
     // "Array() **= 10",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {
       kAllowHarmonyExponentiationOperator};
   RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }