[es6] support template literals after MemberExpression

test/mjsunit/harmony/templates.js

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --harmony-templates --harmony-unicode
 
 var num = 5;
 var str = "str";
 function fn() { return "result"; }
 var obj = {
@@ skipping 405 matching lines @@
       "Iñtërnâtiônàlizætiøn\\u2603\\uD83D\\uDCA9", callSites[0].raw[0]);
   assertEquals("Iñtërnâtiônàlizætiøn☃💩", callSites[1][0]);
   assertEquals("Iñtërnâtiônàlizætiøn☃💩", callSites[1].raw[0]);
 })();
 
 
 (function testExtendedArrayPrototype() {
   Object.defineProperty(Array.prototype, 0, {
     set: function() {
       assertUnreachable();
-    }
+    },
+    configurable: true
   });
   function tag(){}
   tag`a${1}b`;
+  delete Array.prototype[0];
 })();
 
 
 (function testRawLineNormalization() {
   function raw0(callSiteObj) {
     return callSiteObj.raw[0];
   }
   assertEquals(eval("raw0`\r`"), "\n");
   assertEquals(eval("raw0`\r\n`"), "\n");
   assertEquals(eval("raw0`\r\r\n`"), "\n\n");
@@ skipping 71 matching lines @@
   // Allowed in sloppy expression
   assertEquals("\x07", `${"\07"}`);
 
   // Disallowed in template tail
   assertThrows("`${\"\\07\"}\\07`", SyntaxError);
 
   // Disallowed in strict expression
   assertThrows("`${(function() { \"use strict\"; return \"\\07\"; })()}`",
                SyntaxError);
 })();
+
+
+var global = this;
+(function testCallNew() {
+  "use strict";
+  var called = false;
+  var calledWith;
+  global.log = function(x) { called = true; calledWith = x; }
+
+  assertInstanceof(new(Function`log("test")`), Object);
+  assertTrue(called);
+  assertSame("test", calledWith);
+  delete global.log;
+})();
+
+
+(function testCallNew2() {
+  "use strict";
+  var log = [];
+  function tag(x) {
+    log.push(x);
+    if (!(this instanceof tag)) {
+      return tag;
+    }
+    this.x = x === void 0 ? null : x;

[marja, 2015/03/12 11:43:35]

What's the added value of storing this.x, since we already log.push(x) ?

[caitp (gmail), 2015/03/12 13:34:15]

it's distinct because only the one which is actually called as a constructor
will have a valid "this"

+    return this;
+  }
+  var instance = new tag`x``y``z`;
+  assertInstanceof(instance, tag);
+  assertSame(tag.prototype, Object.getPrototypeOf(instance));
+  assertEquals([["x"], ["y"], ["z"], undefined], log);
+  assertSame(null, instance.x);
+})();
+
+
+(function testCallResultOfTagFn() {
+  "use strict";
+  var i = 0;
+  var raw = [];
+  function tag(cs) {
+    var args = Array.prototype.slice.call(arguments);
+    var text = String.raw.apply(null, args);
+    if (i++ < 2) {
+      raw.push("tag;" + text);
+      return tag;
+    }
+
+    raw.push("raw;" + text);
+    return text;
+  }
+  assertEquals("test3", tag`test1``test2``test3`);
+  assertEquals([
+    "tag;test1",
+    "tag;test2",
+    "raw;test3"
+  ], raw);
+})();

[arv (Not doing code reviews), 2015/03/12 15:20:02]

One more thing we could test would be:

new tag `x` `y` ('z')

which I believe should be treated as 

new (tag `x` `y`)('z')

ie construct (tag `x` `y`) with 'y' as a param.