Delete --harmony-computed-property-names 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 1411 matching lines @@
 }
 
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyArrowFunctions,
   kAllowHarmonyRestParameters,
   kAllowHarmonySloppy,
   kAllowHarmonySloppyLet,
-  kAllowHarmonyComputedPropertyNames,
   kAllowHarmonySpreadCalls,
   kAllowHarmonyDestructuring,
   kAllowHarmonySpreadArrays,
   kAllowHarmonyNewTarget,
   kAllowStrongMode,
   kNoLegacyConst
 };
 
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 template <typename Traits>
 void SetParserFlags(i::ParserBase<Traits>* parser,
                     i::EnumSet<ParserFlag> flags) {
   parser->set_allow_lazy(flags.Contains(kAllowLazy));
   parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_arrow_functions(
       flags.Contains(kAllowHarmonyArrowFunctions));
   parser->set_allow_harmony_rest_parameters(
       flags.Contains(kAllowHarmonyRestParameters));
   parser->set_allow_harmony_spreadcalls(
       flags.Contains(kAllowHarmonySpreadCalls));
   parser->set_allow_harmony_sloppy(flags.Contains(kAllowHarmonySloppy));
   parser->set_allow_harmony_sloppy_let(flags.Contains(kAllowHarmonySloppyLet));
-  parser->set_allow_harmony_computed_property_names(
-      flags.Contains(kAllowHarmonyComputedPropertyNames));
   parser->set_allow_harmony_destructuring(
       flags.Contains(kAllowHarmonyDestructuring));
   parser->set_allow_harmony_spread_arrays(
       flags.Contains(kAllowHarmonySpreadArrays));
   parser->set_allow_harmony_new_target(flags.Contains(kAllowHarmonyNewTarget));
   parser->set_allow_strong_mode(flags.Contains(kAllowStrongMode));
   parser->set_allow_legacy_const(!flags.Contains(kNoLegacyConst));
 }
 
 
@@ skipping 3784 matching lines @@
                                    {"(class {set [", "](_) {}});"},
                                    {"(class {[", "]() {}});"},
                                    {"(class {*[", "]() {}});"},
                                    {NULL, NULL}};
   const char* error_data[] = {
     "1, 2",
     "var name",
     NULL};
 
   static const ParserFlag always_flags[] = {
-    kAllowHarmonyComputedPropertyNames,
     kAllowHarmonySloppy,
   };
   RunParserSyncTest(context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 
   const char* name_data[] = {
     "1",
     "1 + 2",
     "'name'",
     "\"name\"",
     "[]",
     "{}",
     NULL};
 
   RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 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[] = {
-    kAllowHarmonyComputedPropertyNames,
     kAllowHarmonySloppy,
   };
   RunParserSyncTest(context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(BasicImportExportParsing) {
   i::FLAG_harmony_modules = true;
 
@@ skipping 272 matching lines @@
   };
   const char* error_data[] = {
     "__proto__: {}, ['__proto__']: {}",
     "__proto__: {}, __proto__() {}",
     "__proto__: {}, get __proto__() {}",
     "__proto__: {}, set __proto__(v) {}",
     "__proto__: {}, __proto__",
     NULL
   };
 
-  static const ParserFlag always_flags[] = {
-    kAllowHarmonyComputedPropertyNames,
-  };
-  RunParserSyncTest(context_data, error_data, kSuccess, NULL, 0,
-                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(context_data, error_data, kSuccess);
 }
 
 
 TEST(DeclarationsError) {
   const char* context_data[][2] = {{"'use strict'; if (true)", ""},
                                    {"'use strict'; if (false) {} else", ""},
                                    {"'use strict'; while (false)", ""},
                                    {"'use strict'; for (;;)", ""},
                                    {"'use strict'; for (x in y)", ""},
                                    {"'use strict'; do ", " while (false)"},
@@ skipping 718 matching lines @@
                  "ReferenceError: In strong mode, using an undeclared global "
                  "variable 'not_there3' is not allowed",
                  *exception));
   }
 }
 
 
 TEST(DestructuringPositiveTests) {
   i::FLAG_harmony_destructuring = true;
   i::FLAG_harmony_arrow_functions = true;
-  i::FLAG_harmony_computed_property_names = true;
 
   const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                    {"var ", " = {};"},
                                    {"'use strict'; const ", " = {};"},
                                    {"function f(", ") {}"},
                                    {"function f(argument1, ", ") {}"},
                                    {"var f = (", ") => {};"},
                                    {"var f = (argument1,", ") => {};"},
                                    {NULL, NULL}};
 
@@ skipping 28 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[] = {kAllowHarmonyComputedPropertyNames,
-                                            kAllowHarmonyArrowFunctions,
+  static const ParserFlag always_flags[] = {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[] = {kAllowHarmonyComputedPropertyNames,
-                                            kAllowHarmonyArrowFunctions,
+  static const ParserFlag always_flags[] = {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 = ", " => {};"},
@@ skipping 148 matching lines @@
     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[] = {kAllowHarmonyComputedPropertyNames,
-                                            kAllowHarmonyArrowFunctions,
+  static const ParserFlag always_flags[] = {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[] = {kAllowHarmonyComputedPropertyNames,
-                                            kAllowHarmonyArrowFunctions,
+  static const ParserFlag always_flags[] = {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[] = {kAllowHarmonyComputedPropertyNames,
-                                            kAllowHarmonyArrowFunctions,
+  static const ParserFlag always_flags[] = {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[] = {
-      kAllowHarmonyComputedPropertyNames, kAllowHarmonyArrowFunctions,
-      kAllowHarmonyRestParameters, kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {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 174 matching lines @@
     "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));
 }