Implement ES6 Template Literals

test/cctest/test-parsing.cc

Index: test/cctest/test-parsing.cc
diff --git a/test/cctest/test-parsing.cc b/test/cctest/test-parsing.cc
index 1909b3e66b4039c3e2548bad2256e1d06d3b6a84..79a73cf087e710e4a6b79d92e149d9585e74e376 100644
--- a/test/cctest/test-parsing.cc
+++ b/test/cctest/test-parsing.cc
@@ -1334,7 +1334,8 @@ enum ParserFlag {
   kAllowHarmonyNumericLiterals,
   kAllowArrowFunctions,
   kAllowClasses,
-  kAllowHarmonyObjectLiterals
+  kAllowHarmonyObjectLiterals,
+  kAllowHarmonyTemplates
 };
 
 
@@ -1357,6 +1358,7 @@ void SetParserFlags(i::ParserBase<Traits>* parser,
       flags.Contains(kAllowHarmonyObjectLiterals));
   parser->set_allow_arrow_functions(flags.Contains(kAllowArrowFunctions));
   parser->set_allow_classes(flags.Contains(kAllowClasses));
+  parser->set_allow_harmony_templates(flags.Contains(kAllowHarmonyTemplates));
 }
 
 
@@ -1656,6 +1658,7 @@ void RunParserSyncTest(const char* context_data[][2],
     kAllowLazy,
     kAllowModules,
     kAllowNativesSyntax,
+    kAllowHarmonyTemplates
   };
   ParserFlag* generated_flags = NULL;
   if (flags == NULL) {
@@ -4306,3 +4309,73 @@ TEST(InvalidUnicodeEscapes) {
     NULL};
   RunParserSyncTest(context_data, data, kError);
 }
+
+
+TEST(ScanTemplateLiterals) {
+  const char* context_data[][2] = {{"'use strict';", ""},
+                                   {"function foo(){ 'use strict';"
+                                    "  var a, b, c; return ", "}"},
+                                   {NULL, NULL}};
+
+  const char* data[] = {
+      "`no-subst-template`",

[arv (Not doing code reviews), 2014/11/07 16:55:50]

Also include an empty one

``

[caitp (gmail), 2014/11/07 17:13:08]

Done.

+      "`template-head${a}`",
+      "`${a}template-tail`",

[arv (Not doing code reviews), 2014/11/07 16:55:50]

How about one with only a place holder

`${a}`

[caitp (gmail), 2014/11/07 17:13:08]

Done.

+      "`template-head${a}template-tail`",
+      "`${a}${b}${c}`",
+      "`a${a}b${b}c${c}`",
+      "`${a}a${b}b${c}c`",
+      "`foo\n\nbar\r\nbaz`",
+      "`foo\n\n${  bar  }\r\nbaz`",
+      NULL};
+  static const ParserFlag always_flags[] = {kAllowHarmonyTemplates};
+  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
+                    arraysize(always_flags));
+}
+
+
+TEST(ScanTaggedTemplateLiterals) {
+  const char* context_data[][2] = {{"'use strict';", ""},
+                                   {"function foo(){ 'use strict';"
+                                    "  function tag() {}"
+                                    "  var a, b, c; return ", "}"},
+                                   {NULL, NULL}};
+
+  const char* data[] = {
+      "tag `no-subst-template`",
+      "tag`template-head${a}`",
+      "tag `${a}template-tail`",
+      "tag   `template-head${a}template-tail`",
+      "tag\n`${a}${b}${c}`",
+      "tag\r\n`a${a}b${b}c${c}`",
+      "tag    `${a}a${b}b${c}c`",
+      "tag\t`foo\n\nbar\r\nbaz`",
+      "tag\r`foo\n\n${  bar  }\r\nbaz`",
+      NULL};
+  static const ParserFlag always_flags[] = {kAllowHarmonyTemplates};
+  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
+                    arraysize(always_flags));
+}
+
+
+TEST(ScanUnterminatedTemplateLiterals) {
+  const char* context_data[][2] = {{"'use strict';", ""},
+                                   {"function foo(){ 'use strict';"
+                                    "  var a, b, c; return ", "}"},
+                                   {NULL, NULL}};
+
+  const char* data[] = {
+      "`no-subst-template",
+      "`template-head${a}",
+      "`${a}template-tail",
+      "`template-head${a}template-tail",
+      "`${a}${b}${c}",
+      "`a${a}b${b}c${c}",
+      "`${a}a${b}b${c}c",
+      "`foo\n\nbar\r\nbaz",
+      "`foo\n\n${  bar  }\r\nbaz",
+      NULL};
+  static const ParserFlag always_flags[] = {kAllowHarmonyTemplates};
+  RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
+                    arraysize(always_flags));
+}