[parser] Lift template literal invalid escape restriction

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 1245 matching lines @@
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyRestrictiveGenerators,
   kAllowHarmonyTrailingCommas,
   kAllowHarmonyClassFields,
   kAllowHarmonyObjectRestSpread,
   kAllowHarmonyDynamicImport,
   kAllowHarmonyAsyncIteration,
+  kAllowHarmonyTemplateEscapes,
 };
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 void SetGlobalFlags(i::EnumSet<ParserFlag> flags) {
   i::FLAG_allow_natives_syntax = flags.Contains(kAllowNatives);
   i::FLAG_harmony_function_sent = flags.Contains(kAllowHarmonyFunctionSent);
   i::FLAG_harmony_restrictive_generators =
       flags.Contains(kAllowHarmonyRestrictiveGenerators);
   i::FLAG_harmony_trailing_commas = flags.Contains(kAllowHarmonyTrailingCommas);
   i::FLAG_harmony_class_fields = flags.Contains(kAllowHarmonyClassFields);
   i::FLAG_harmony_object_rest_spread =
       flags.Contains(kAllowHarmonyObjectRestSpread);
   i::FLAG_harmony_dynamic_import = flags.Contains(kAllowHarmonyDynamicImport);
   i::FLAG_harmony_async_iteration = flags.Contains(kAllowHarmonyAsyncIteration);
+  i::FLAG_harmony_template_escapes =
+      flags.Contains(kAllowHarmonyTemplateEscapes);
 }
 
 void SetParserFlags(i::PreParser* parser, i::EnumSet<ParserFlag> flags) {
   parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
   parser->set_allow_harmony_restrictive_generators(
       flags.Contains(kAllowHarmonyRestrictiveGenerators));
   parser->set_allow_harmony_trailing_commas(
       flags.Contains(kAllowHarmonyTrailingCommas));
   parser->set_allow_harmony_class_fields(
       flags.Contains(kAllowHarmonyClassFields));
   parser->set_allow_harmony_object_rest_spread(
       flags.Contains(kAllowHarmonyObjectRestSpread));
   parser->set_allow_harmony_dynamic_import(
       flags.Contains(kAllowHarmonyDynamicImport));
   parser->set_allow_harmony_async_iteration(
       flags.Contains(kAllowHarmonyAsyncIteration));
+  parser->set_allow_harmony_template_escapes(
+      flags.Contains(kAllowHarmonyTemplateEscapes));
 }
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
                              ParserSyncTestResult result,
                              bool is_module = false, bool test_preparser = true,
                              bool ignore_error_msg = false) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
@@ skipping 5747 matching lines @@
     "{ ...y, b: 1}",
     "{ ...1}",
     "{ ...null}",
     "{ ...undefined}",
     "{ ...1 in {}}",
     "{ ...[]}",
     "{ ...async function() { }}",
     "{ ...async () => { }}",
     "{ ...new Foo()}",
     NULL};
+  // clang-format on
 
   static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
                     arraysize(flags));
 }
 
 TEST(ObjectSpreadNegativeTests) {
   const char* context_data[][2] = {{"x = ", ""},
                                    {"'use strict'; x = ", ""},
                                    {NULL, NULL}};
 
   // clang-format off
   const char* data[] = {
     "{ ...var z = y}",
     "{ ...var}",
     "{ ...foo bar}",
     NULL};
 
   static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
   RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
                     arraysize(flags));
 }
 
+TEST(TemplateEscapesPositiveTests) {
+  // clang-format off
+  const char* context_data[][2] = {
+    {"", ""},
+    {"'use strict';", ""},
+    {NULL, NULL}};
+
+  // clang-format off
+  const char* data[] = {
+    "tag`\\01`",
+    "tag`\\01${0}right`",
+    "tag`left${0}\\01`",
+    "tag`left${0}\\01${1}right`",
+    "tag`\\1`",
+    "tag`\\1${0}right`",
+    "tag`left${0}\\1`",
+    "tag`left${0}\\1${1}right`",
+    "tag`\\xg`",
+    "tag`\\xg${0}right`",
+    "tag`left${0}\\xg`",
+    "tag`left${0}\\xg${1}right`",
+    "tag`\\xAg`",
+    "tag`\\xAg${0}right`",
+    "tag`left${0}\\xAg`",
+    "tag`left${0}\\xAg${1}right`",
+    "tag`\\u0`",
+    "tag`\\u0${0}right`",
+    "tag`left${0}\\u0`",
+    "tag`left${0}\\u0${1}right`",
+    "tag`\\u0g`",
+    "tag`\\u0g${0}right`",
+    "tag`left${0}\\u0g`",
+    "tag`left${0}\\u0g${1}right`",
+    "tag`\\u00g`",
+    "tag`\\u00g${0}right`",
+    "tag`left${0}\\u00g`",
+    "tag`left${0}\\u00g${1}right`",
+    "tag`\\u000g`",
+    "tag`\\u000g${0}right`",
+    "tag`left${0}\\u000g`",
+    "tag`left${0}\\u000g${1}right`",
+    "tag`\\u{}`",
+    "tag`\\u{}${0}right`",
+    "tag`left${0}\\u{}`",
+    "tag`left${0}\\u{}${1}right`",
+    "tag`\\u{-0}`",
+    "tag`\\u{-0}${0}right`",
+    "tag`left${0}\\u{-0}`",
+    "tag`left${0}\\u{-0}${1}right`",
+    "tag`\\u{g}`",
+    "tag`\\u{g}${0}right`",
+    "tag`left${0}\\u{g}`",
+    "tag`left${0}\\u{g}${1}right`",
+    "tag`\\u{0`",
+    "tag`\\u{0${0}right`",
+    "tag`left${0}\\u{0`",
+    "tag`left${0}\\u{0${1}right`",
+    "tag`\\u{\\u{0}`",
+    "tag`\\u{\\u{0}${0}right`",
+    "tag`left${0}\\u{\\u{0}`",
+    "tag`left${0}\\u{\\u{0}${1}right`",
+    "tag`\\u{110000}`",
+    "tag`\\u{110000}${0}right`",
+    "tag`left${0}\\u{110000}`",
+    "tag`left${0}\\u{110000}${1}right`",
+    NULL};
+  // clang-format on
+
+  // No error with flag
+  static const ParserFlag flags[] = {kAllowHarmonyTemplateEscapes};
+  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
+                    arraysize(flags));
+
+  // Still an error without flag
+  RunParserSyncTest(context_data, data, kError);
+}
+
+TEST(TemplateEscapesNegativeTests) {
+  // clang-format off
+  const char* context_data[][2] = {
+    {"", ""},
+    {"'use strict';", ""},
+    {NULL, NULL}};
+
+  // clang-format off
+  const char* data[] = {
+    "`\\01`",
+    "`\\01${0}right`",
+    "`left${0}\\01`",
+    "`left${0}\\01${1}right`",
+    "`\\1`",
+    "`\\1${0}right`",
+    "`left${0}\\1`",
+    "`left${0}\\1${1}right`",
+    "`\\xg`",
+    "`\\xg${0}right`",
+    "`left${0}\\xg`",
+    "`left${0}\\xg${1}right`",
+    "`\\xAg`",
+    "`\\xAg${0}right`",
+    "`left${0}\\xAg`",
+    "`left${0}\\xAg${1}right`",
+    "`\\u0`",
+    "`\\u0${0}right`",
+    "`left${0}\\u0`",
+    "`left${0}\\u0${1}right`",
+    "`\\u0g`",
+    "`\\u0g${0}right`",
+    "`left${0}\\u0g`",
+    "`left${0}\\u0g${1}right`",
+    "`\\u00g`",
+    "`\\u00g${0}right`",
+    "`left${0}\\u00g`",
+    "`left${0}\\u00g${1}right`",
+    "`\\u000g`",
+    "`\\u000g${0}right`",
+    "`left${0}\\u000g`",
+    "`left${0}\\u000g${1}right`",
+    "`\\u{}`",
+    "`\\u{}${0}right`",
+    "`left${0}\\u{}`",
+    "`left${0}\\u{}${1}right`",
+    "`\\u{-0}`",
+    "`\\u{-0}${0}right`",
+    "`left${0}\\u{-0}`",
+    "`left${0}\\u{-0}${1}right`",
+    "`\\u{g}`",
+    "`\\u{g}${0}right`",
+    "`left${0}\\u{g}`",
+    "`left${0}\\u{g}${1}right`",
+    "`\\u{0`",
+    "`\\u{0${0}right`",
+    "`left${0}\\u{0`",
+    "`left${0}\\u{0${1}right`",
+    "`\\u{\\u{0}`",
+    "`\\u{\\u{0}${0}right`",
+    "`left${0}\\u{\\u{0}`",
+    "`left${0}\\u{\\u{0}${1}right`",
+    "`\\u{110000}`",
+    "`\\u{110000}${0}right`",
+    "`left${0}\\u{110000}`",
+    "`left${0}\\u{110000}${1}right`",
+    "`\\1``\\2`",
+    NULL};
+  // clang-format on
+
+  // Error with flag
+  static const ParserFlag flags[] = {kAllowHarmonyTemplateEscapes};
+  RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                    arraysize(flags));
+
+  // Still an error without flag
+  RunParserSyncTest(context_data, data, kError);
+}
+
 TEST(DestructuringPositiveTests) {
   const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                    {"var ", " = {};"},
                                    {"'use strict'; const ", " = {};"},
                                    {"function f(", ") {}"},
                                    {"function f(argument1, ", ") {}"},
                                    {"var f = (", ") => {};"},
                                    {"var f = (argument1,", ") => {};"},
                                    {"try {} catch(", ") {}"},
                                    {NULL, NULL}};
@@ skipping 2664 matching lines @@
     // "for await (x of []) async function a() {};",
     // "for await (x of []) async function a() {}; return a;",
     NULL
   };
 
   // clang-format on
   static const ParserFlag always_flags[] = {kAllowHarmonyAsyncIteration};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }