WIP: 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 1359 matching lines @@
 
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyModules,
   kAllowHarmonyArrowFunctions,
   kAllowHarmonyClasses,
   kAllowHarmonyObjectLiterals,
   kAllowHarmonyRestParameters,
+  kAllowHarmonyNewTarget,
   kAllowHarmonySloppy,
   kAllowHarmonyUnicode,
   kAllowHarmonyComputedPropertyNames,
   kAllowStrongMode,
   kAllowHarmonySpreadCalls
 };
 
 
 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_new_target(flags.Contains(kAllowHarmonyNewTarget));
   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_strong_mode(flags.Contains(kAllowStrongMode));
 }
 
 
@@ skipping 4822 matching lines @@
     v8::Script::Compile(v8_str(script3));
     CHECK(try_catch2.HasCaught());
     v8::String::Utf8Value exception(try_catch2.Exception());
     CHECK_EQ(0,
              strcmp(
                  "ReferenceError: In strong mode, using an undeclared global "
                  "variable 'not_there3' is not allowed",
                  *exception));
   }
 }
+
+
+TEST(NewTarget) {
+  const char* bad_context_data[][2] = {{"", ""}, {"'use strict';", ""}, {NULL}};
+  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* 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,
+  };
+
+  RunParserSyncTest(bad_context_data, data, kError, NULL, 0, always_flags,
+                    arraysize(always_flags));
+  RunParserSyncTest(good_context_data, data, kSuccess, NULL, 0, always_flags,
+                    arraysize(always_flags));
+}