Revert of [es6] Parsing of new.target

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 1368 matching lines @@
   kAllowHarmonyArrowFunctions,
   kAllowHarmonyClasses,
   kAllowHarmonyObjectLiterals,
   kAllowHarmonyRestParameters,
   kAllowHarmonySloppy,
   kAllowHarmonyUnicode,
   kAllowHarmonyComputedPropertyNames,
   kAllowHarmonySpreadCalls,
   kAllowHarmonyDestructuring,
   kAllowHarmonySpreadArrays,
-  kAllowHarmonyNewTarget,
   kAllowStrongMode
 };
 
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
@@ skipping 13 matching lines @@
   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(
       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));
 }
 
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
                              ParserSyncTestResult result) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
@@ skipping 5176 matching lines @@
     "[a, ...]",
     "[..., ]",
     "[..., ...]",
     "[ (...a)]",
     NULL};
   // clang-format on
   static const ParserFlag always_flags[] = {kAllowHarmonySpreadArrays};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
-
-
-TEST(NewTarget) {
-  // clang-format off
-  const char* good_context_data[][2] = {
-    {"function f() {", "}"},
-    {"'use strict'; function f() {", "}"},
-    {"var f = function() {", "}"},
-    {"'use strict'; var f = function() {", "}"},
-    {"({m: function() {", "}})"},
-    {"'use strict'; ({m: function() {", "}})"},
-    {"({m() {", "}})"},
-    {"'use strict'; ({m() {", "}})"},
-    {"({get x() {", "}})"},
-    {"'use strict'; ({get x() {", "}})"},
-    {"({set x(_) {", "}})"},
-    {"'use strict'; ({set x(_) {", "}})"},
-    {"class C {m() {", "}}"},
-    {"class C {get x() {", "}}"},
-    {"class C {set x(_) {", "}}"},
-    {NULL}
-  };
-
-  const char* bad_context_data[][2] = {
-    {"", ""},
-    {"'use strict';", ""},
-    {NULL}
-  };
-
-  const char* data[] = {
-    "new.target",
-    "{ 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[] = {
-    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));
-}