[es6] Remove harmony-object-literal 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 1050 matching lines @@
                   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;
       i::ParseInfo info(&zone, script);
       i::Parser parser(&info);
       parser.set_allow_harmony_arrow_functions(true);
       parser.set_allow_harmony_classes(true);
-      parser.set_allow_harmony_object_literals(true);
       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.function() != NULL);
 
       i::Scope* script_scope = info.function()->scope();
       CHECK(script_scope->is_script_scope());
       CHECK_EQ(1, script_scope->inner_scopes()->length());
@@ skipping 291 matching lines @@
   return i::MessageTemplate::FormatMessage(isolate, message, arg_object);
 }
 
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyModules,
   kAllowHarmonyArrowFunctions,
   kAllowHarmonyClasses,
-  kAllowHarmonyObjectLiterals,
   kAllowHarmonyRestParameters,
   kAllowHarmonySloppy,
   kAllowHarmonyUnicode,
   kAllowHarmonyComputedPropertyNames,
   kAllowHarmonySpreadCalls,
   kAllowHarmonyDestructuring,
   kAllowHarmonySpreadArrays,
   kAllowHarmonyNewTarget,
   kAllowStrongMode
 };
 
 
 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_modules(flags.Contains(kAllowHarmonyModules));
-  parser->set_allow_harmony_object_literals(
-      flags.Contains(kAllowHarmonyObjectLiterals));
   parser->set_allow_harmony_arrow_functions(
       flags.Contains(kAllowHarmonyArrowFunctions));
   parser->set_allow_harmony_classes(flags.Contains(kAllowHarmonyClasses));
   parser->set_allow_harmony_rest_params(
       flags.Contains(kAllowHarmonyRestParameters));
   parser->set_allow_harmony_spreadcalls(
       flags.Contains(kAllowHarmonySpreadCalls));
   parser->set_allow_harmony_sloppy(flags.Contains(kAllowHarmonySloppy));
   parser->set_allow_harmony_unicode(flags.Contains(kAllowHarmonyUnicode));
   parser->set_allow_harmony_computed_property_names(
@@ skipping 2299 matching lines @@
     "new super.x()",
     "new super[27]",
     "new super[27]()",
     "z.super",  // Ok, property lookup.
     NULL
   };
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyArrowFunctions,
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(SuperErrors) {
   const char* context_data[][2] = {
     {"class C { m() { ", "; } }"},
@@ skipping 12 matching lines @@
     "new super()",
     "new super(12, 45)",
     "new new super",
     "new new super()",
     "new new super()()",
     NULL
   };
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, expression_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 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[] = {
     kAllowHarmonyArrowFunctions,
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   const char* error_data[] = {
     "class C { constructor() { super(); } }",
     "class C { method() { super(); } }",
     "class C { method() { () => super(); } }",
     "class C { *method() { super(); } }",
@@ skipping 34 matching lines @@
     "new super.x;",
     "new super.x();",
     "() => new super.x;",
     "() => new super.x();",
     NULL
   };
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyArrowFunctions,
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, expression_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(SuperNewErrors) {
   const char* context_data[][2] = {
     {"class C { method() { ", " } }"},
@@ skipping 17 matching lines @@
     "new super;",
     "new super();",
     "() => new super;",
     "() => new super();",
     NULL
   };
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyArrowFunctions,
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(SuperErrorsNonMethods) {
   // super is only allowed in methods, accessors and constructors.
   const char* context_data[][2] = {
@@ skipping 23 matching lines @@
     "super()",
     "new super.x",
     "new super.x()",
     "new super[27]",
     "new super[27]()",
     NULL
   };
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(NoErrorsMethodDefinition) {
   const char* context_data[][2] = {{"({", "});"},
                                    {"'use strict'; ({", "});"},
                                    {"({*", "});"},
                                    {"'use strict'; ({*", "});"},
                                    {NULL, NULL}};
 
   const char* object_literal_body_data[] = {
     "m() {}",
     "m(x) { return x; }",
     "m(x, y) {}, n() {}",
     "set(x, y) {}",
     "get(x, y) {}",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, object_literal_body_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, object_literal_body_data, kSuccess);
 }
 
 
 TEST(MethodDefinitionNames) {
   const char* context_data[][2] = {{"({", "(x, y) {}});"},
                                    {"'use strict'; ({", "(x, y) {}});"},
                                    {"({*", "(x, y) {}});"},
                                    {"'use strict'; ({*", "(x, y) {}});"},
                                    {NULL, NULL}};
 
@@ skipping 53 matching lines @@
     "try",
     "typeof",
     "var",
     "void",
     "while",
     "with",
     "yield",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, name_data, kSuccess);
 }
 
 
 TEST(MethodDefinitionStrictFormalParamereters) {
   const char* context_data[][2] = {{"({method(", "){}});"},
                                    {"'use strict'; ({method(", "){}});"},
                                    {"({*method(", "){}});"},
                                    {"'use strict'; ({*method(", "){}});"},
                                    {NULL, NULL}};
 
   const char* params_data[] = {
     "x, x",
     "x, y, x",
     "var",
     "const",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, params_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, params_data, kError);
 }
 
 
 TEST(MethodDefinitionEvalArguments) {
   const char* strict_context_data[][2] =
       {{"'use strict'; ({method(", "){}});"},
        {"'use strict'; ({*method(", "){}});"},
        {NULL, NULL}};
   const char* sloppy_context_data[][2] =
       {{"({method(", "){}});"},
        {"({*method(", "){}});"},
        {NULL, NULL}};
 
   const char* data[] = {
       "eval",
       "arguments",
       NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-
   // 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(MethodDefinitionDuplicateEvalArguments) {
   const char* context_data[][2] =
       {{"'use strict'; ({method(", "){}});"},
        {"'use strict'; ({*method(", "){}});"},
        {"({method(", "){}});"},
        {"({*method(", "){}});"},
        {NULL, NULL}};
 
   const char* data[] = {
       "eval, eval",
       "eval, a, eval",
       "arguments, arguments",
       "arguments, a, arguments",
       NULL};
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-
   // 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(MethodDefinitionDuplicateProperty) {
   const char* context_data[][2] = {{"'use strict'; ({", "});"},
                                    {NULL, NULL}};
 
   const char* params_data[] = {
     "x: 1, x() {}",
     "x() {}, x: 1",
@@ skipping 13 matching lines @@
     "*x() {}, *x() {}",
     "*x() {}, y() {}, *x() {}",
     "*x() {}, *\"x\"() {}",
     "*x() {}, *'x'() {}",
     "*0() {}, *'0'() {}",
     "*1.0() {}, 1: 1",
 
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, params_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, params_data, kSuccess);
 }
 
 
 TEST(ClassExpressionNoErrors) {
   const char* context_data[][2] = {{"(", ");"},
                                    {"var C = ", ";"},
                                    {"bar, ", ";"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class {}",
@@ skipping 66 matching lines @@
     "static get static() {}",
     "static set static(v) {}",
     "*static() {}",
     "*get() {}",
     "*set() {}",
     "static *g() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassPropertyNameNoErrors) {
   const char* context_data[][2] = {{"(class {", "() {}});"},
                                    {"(class { get ", "() {}});"},
@@ skipping 38 matching lines @@
     "for",
     "while",
     "do",
     "try",
     "catch",
     "finally",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassExpressionErrors) {
   const char* context_data[][2] = {{"(", ");"},
                                    {"var C = ", ";"},
@@ skipping 11 matching lines @@
     "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[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassDeclarationErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"{", "}"},
@@ skipping 47 matching lines @@
     "private",
     "protected",
     "public",
     "static",
     "var",
     "yield",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_name, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ClassGetterParamNameErrors) {
   const char* context_data[][2] = {
     {"class C { get name(", ") {} }"},
@@ skipping 13 matching lines @@
     "private",
     "protected",
     "public",
     "static",
     "var",
     "yield",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_name, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 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[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 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[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 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[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 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[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 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[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 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[] = {
     kAllowHarmonyClasses,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(ObjectLiteralPropertyShorthandKeywordsError) {
   const char* context_data[][2] = {{"({", "});"},
                                    {"'use strict'; ({", "});"},
@@ skipping 32 matching lines @@
     "true",
     "try",
     "typeof",
     "var",
     "void",
     "while",
     "with",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, name_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, name_data, kError);
 }
 
 
 TEST(ObjectLiteralPropertyShorthandStrictKeywords) {
   const char* context_data[][2] = {{"({", "});"},
                                    {NULL, NULL}};
 
   const char* name_data[] = {
     "implements",
     "interface",
     "let",
     "package",
     "private",
     "protected",
     "public",
     "static",
     "yield",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, name_data, kSuccess);
 
   const char* context_strict_data[][2] = {{"'use strict'; ({", "});"},
                                           {NULL, NULL}};
-  RunParserSyncTest(context_strict_data, name_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_strict_data, name_data, kError);
 }
 
 
 TEST(ObjectLiteralPropertyShorthandError) {
   const char* context_data[][2] = {{"({", "});"},
                                    {"'use strict'; ({", "});"},
                                    {NULL, NULL}};
 
   const char* name_data[] = {
     "1",
     "1.2",
     "0",
     "0.1",
     "1.0",
     "1e1",
     "0x1",
     "\"s\"",
     "'s'",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, name_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, name_data, kError);
 }
 
 
 TEST(ObjectLiteralPropertyShorthandYieldInGeneratorError) {
   const char* context_data[][2] = {{"", ""},
                                    {NULL, NULL}};
 
   const char* name_data[] = {
     "function* g() { ({yield}); }",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, name_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, name_data, kError);
 }
 
 
 TEST(ConstParsingInForIn) {
   const char* context_data[][2] = {{"'use strict';", ""},
                                    {"function foo(){ 'use strict';", "}"},
                                    {NULL, NULL}};
 
   const char* data[] = {
       "for(const x = 1; ; ) {}",
@@ skipping 611 matching lines @@
                                    {"(class {*[", "]() {}});"},
                                    {NULL, NULL}};
   const char* error_data[] = {
     "1, 2",
     "var name",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses,
     kAllowHarmonyComputedPropertyNames,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy,
   };
   RunParserSyncTest(context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   const char* name_data[] = {
     "1",
     "1 + 2",
     "'name'",
     "\"name\"",
@@ skipping 10 matching lines @@
   const char* context_data[][2] = {{"({", "});"},
                                    {NULL, NULL}};
   const char* error_data[] = {
     "a: 1, [2]",
     "[1], a: 1",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyClasses,
     kAllowHarmonyComputedPropertyNames,
-    kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy,
   };
   RunParserSyncTest(context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(BasicImportExportParsing) {
   const char* kSources[] = {
       "export let x = 0;",
@@ skipping 277 matching lines @@
     "__proto__: {}, ['__proto__']: {}",
     "__proto__: {}, __proto__() {}",
     "__proto__: {}, get __proto__() {}",
     "__proto__: {}, set __proto__(v) {}",
     "__proto__: {}, __proto__",
     NULL
   };
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyComputedPropertyNames,
-    kAllowHarmonyObjectLiterals,
   };
   RunParserSyncTest(context_data, error_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(DeclarationsError) {
   const char* context_data[][2] = {{"'use strict'; if (true)", ""},
                                    {"'use strict'; if (false) {} else", ""},
                                    {"'use strict'; while (false)", ""},
@@ skipping 92 matching lines @@
       "class C {static arguments() {}}",
       "class C {static *eval() {}}",
       "class C {static *arguments() {}}",
       "class C {static get eval() {}}",
       "class C {static get arguments() {}}",
       "class C {static set eval(_) {}}",
       "class C {static set arguments(_) {}}",
 
       NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyClasses, kAllowHarmonyObjectLiterals, kAllowStrongMode};
+  static const ParserFlag always_flags[] = {kAllowHarmonyClasses,
+                                            kAllowStrongMode};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(FunctionLiteralDuplicateParameters) {
   const char* strict_context_data[][2] =
       {{"'use strict';(function(", "){})();"},
        {"(function(", ") { 'use strict'; })();"},
        {"'use strict'; function fn(", ") {}; fn();"},
@@ skipping 164 matching lines @@
       "class C { constructor() { this.a = {b: 1}; this.a.b = 0 } }",
       "class C { constructor() { this.a = function(){}; this.a() } }",
       NULL};
 
   const char* success_data[] = {
       "class C { constructor() { this.a = 0; } }",
       "class C { constructor() { label: 0; this.a = 0; this.b = 6; } }",
       NULL};
 
   static const ParserFlag always_flags[] = {
-      kAllowStrongMode, kAllowHarmonyClasses, kAllowHarmonyObjectLiterals,
-      kAllowHarmonyArrowFunctions
-  };
+      kAllowStrongMode, kAllowHarmonyClasses, kAllowHarmonyArrowFunctions};
   RunParserSyncTest(sloppy_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, error_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strong_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   RunParserSyncTest(sloppy_context_data, success_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, success_data, kSuccess, NULL, 0,
@@ skipping 33 matching lines @@
       NULL};
 
   const char* success_data[] = {
       "class C extends Object { constructor() { super(); } }",
       "class C extends Object { constructor() { label: 66; super(); } }",
       "class C extends Object { constructor() { super(3); this.x = 0; } }",
       "class C extends Object { constructor() { 3; super(3); this.x = 0; } }",
       NULL};
 
   static const ParserFlag always_flags[] = {
-      kAllowStrongMode, kAllowHarmonyClasses, kAllowHarmonyObjectLiterals,
-      kAllowHarmonyArrowFunctions
-  };
+      kAllowStrongMode, kAllowHarmonyClasses, kAllowHarmonyArrowFunctions};
   RunParserSyncTest(sloppy_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, error_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strong_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   RunParserSyncTest(sloppy_context_data, success_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, success_data, kSuccess, NULL, 0,
@@ skipping 24 matching lines @@
   const char* success_data[] = {
       "class C extends Object { constructor() { super(); return; } }",
       "class C extends Object { constructor() { super(); { return } } }",
       "class C extends Object { constructor() { super(); if (1) return; } }",
       "class C { constructor() { this.a = 0; return; } }",
       "class C { constructor() { this.a = 0; { return; }  } }",
       "class C { constructor() { this.a = 0; if (0) return; 65; } }",
       "class C extends Array { constructor() { super(); this.a = 9; return } }",
       NULL};
 
-  static const ParserFlag always_flags[] = {
-      kAllowStrongMode, kAllowHarmonyClasses, kAllowHarmonyObjectLiterals
-  };
+  static const ParserFlag always_flags[] = {kAllowStrongMode,
+                                            kAllowHarmonyClasses};
   RunParserSyncTest(sloppy_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, error_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strong_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   RunParserSyncTest(sloppy_context_data, success_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, success_data, kSuccess, NULL, 0,
@@ skipping 374 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[] = {
-      kAllowHarmonyObjectLiterals, kAllowHarmonyComputedPropertyNames,
-      kAllowHarmonyArrowFunctions, kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyComputedPropertyNames,
+                                            kAllowHarmonyArrowFunctions,
+                                            kAllowHarmonyDestructuring};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(DestructuringNegativeTests) {
   i::FLAG_harmony_destructuring = true;
   i::FLAG_harmony_arrow_functions = true;
   i::FLAG_harmony_computed_property_names = true;
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyObjectLiterals, kAllowHarmonyComputedPropertyNames,
-      kAllowHarmonyArrowFunctions, kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyComputedPropertyNames,
+                                            kAllowHarmonyArrowFunctions,
+                                            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,", ") => {};"},
@@ skipping 121 matching lines @@
 }
 
 
 TEST(DestructuringDisallowPatternsInForVarIn) {
   i::FLAG_harmony_destructuring = true;
   static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
   const char* context_data[][2] = {
       {"", ""}, {"function f() {", "}"}, {NULL, NULL}};
   // clang-format off
   const char* error_data[] = {
-    "for (var {x} = {} in null);",
-    "for (var {x} = {} of null);",
     "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));
 
   // 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));
 }
 
 
 TEST(DestructuringDuplicateParams) {
   i::FLAG_harmony_destructuring = true;
   i::FLAG_harmony_arrow_functions = true;
   i::FLAG_harmony_computed_property_names = true;
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyObjectLiterals, kAllowHarmonyComputedPropertyNames,
-      kAllowHarmonyArrowFunctions, kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyComputedPropertyNames,
+                                            kAllowHarmonyArrowFunctions,
+                                            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));
 }
 
 
 TEST(DestructuringDuplicateParamsSloppy) {
   i::FLAG_harmony_destructuring = true;
   i::FLAG_harmony_arrow_functions = true;
   i::FLAG_harmony_computed_property_names = true;
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyObjectLiterals, kAllowHarmonyComputedPropertyNames,
-      kAllowHarmonyArrowFunctions, kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyComputedPropertyNames,
+                                            kAllowHarmonyArrowFunctions,
+                                            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));
 }
 
 
 TEST(DestructuringDisallowPatternsInSingleParamArrows) {
   i::FLAG_harmony_destructuring = true;
   i::FLAG_harmony_arrow_functions = true;
   i::FLAG_harmony_computed_property_names = true;
-  static const ParserFlag always_flags[] = {
-      kAllowHarmonyObjectLiterals, kAllowHarmonyComputedPropertyNames,
-      kAllowHarmonyArrowFunctions, kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {kAllowHarmonyComputedPropertyNames,
+                                            kAllowHarmonyArrowFunctions,
+                                            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));
 }
 
 
 TEST(DestructuringDisallowPatternsInRestParams) {
   i::FLAG_harmony_destructuring = true;
   i::FLAG_harmony_arrow_functions = true;
   i::FLAG_harmony_rest_parameters = true;
   i::FLAG_harmony_computed_property_names = true;
   static const ParserFlag always_flags[] = {
-      kAllowHarmonyObjectLiterals, kAllowHarmonyComputedPropertyNames,
-      kAllowHarmonyArrowFunctions, kAllowHarmonyRestParameters,
-      kAllowHarmonyDestructuring};
+      kAllowHarmonyComputedPropertyNames, kAllowHarmonyArrowFunctions,
+      kAllowHarmonyRestParameters, 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 91 matching lines @@
     "if (1) {} else { new.target }",
     "while (0) { new.target }",
     "do { new.target } while (0)",
     NULL
   };
 
   static const ParserFlag always_flags[] = {
     kAllowHarmonyArrowFunctions,
     kAllowHarmonyClasses,
     kAllowHarmonyNewTarget,
-    kAllowHarmonyObjectLiterals,
     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));
 }