Call ToString for template literal placeholders

src/codegeneration/TemplateLiteralTransformer.js

@@ -13,11 +13,10 @@
 // limitations under the License.
 
 import {
-  BINARY_EXPRESSION,
   COMMA_EXPRESSION,
-  CONDITIONAL_EXPRESSION,
+  TEMPLATE_LITERAL_EXPRESSION,
   TEMPLATE_LITERAL_PORTION,
-  TEMPLATE_LITERAL_EXPRESSION
+  TEMPLATE_SUBSTITUTION
 } from '../syntax/trees/ParseTreeType.js';
 import {
   LiteralExpression,
@@ -27,10 +26,7 @@ import {LiteralToken} from '../syntax/LiteralToken.js';
 import {ParseTreeTransformer} from './ParseTreeTransformer.js';
 import {TempVarTransformer} from './TempVarTransformer.js';
 import {
-  PERCENT,
   PLUS,
-  SLASH,
-  STAR,
   STRING
 } from '../syntax/TokenType.js';
 import {
@@ -237,19 +233,7 @@ export class TemplateLiteralTransformer extends TempVarTransformer {
   transformTemplateSubstitution(tree) {
     let transformedTree = this.transformAny(tree.expression);
     // Wrap in a paren expression if needed.
-    switch (transformedTree.type) {
-      case BINARY_EXPRESSION:
-        // Only * / and % have higher priority than +.
-        switch (transformedTree.operator.type) {
-          case STAR:
-          case PERCENT:
-          case SLASH:
-            return transformedTree;
-        }
-        return createParenExpression(transformedTree);
-
-      case COMMA_EXPRESSION:
-      case CONDITIONAL_EXPRESSION:
+    if (transformedTree.type === COMMA_EXPRESSION) {
         return createParenExpression(transformedTree);
     }
 
@@ -261,7 +245,7 @@ export class TemplateLiteralTransformer extends TempVarTransformer {
   }
 
   createDefaultTemplateLiteral(tree) {
-    // convert to ("a" + b + "c" + d + "")
+    // convert to ("a" + String(b) + "c" + String(d) + "")
     let length = tree.elements.length;
     if (length === 0) {
       let loc = tree.location;
@@ -283,6 +267,9 @@ export class TemplateLiteralTransformer extends TempVarTransformer {
           binaryExpression = binaryExpression.right;
       }
       let transformedTree = this.transformAny(tree.elements[i]);
+      if (element.type === TEMPLATE_SUBSTITUTION) {
+        transformedTree = parseExpression `String(${transformedTree})`;
+      }
       binaryExpression = createBinaryExpression(binaryExpression, plusToken,
                                               transformedTree);
     }

test/feature/TemplateLiterals/TaggedToStringSustitutionOrder.js

@@ -0,0 +1,41 @@
+var subs = [];
+var log = [];
+var tagged = [];
+function getter(name, value) {
+  return {
+    get: function() {
+      log.push('get' + name);
+      return value;
+    },
+    set: function(v) {
+      log.push('set' + name);
+    }
+  };
+}
+Object.defineProperties(subs, {
+  0: getter(0, 1),
+  1: getter(1, 2),
+  2: getter(2, 3)
+});
+function tag(cs) {
+  var substitutions = arguments.length - 1;
+  var cooked = cs.length;
+  var e = cs[0];
+  var i = 0;
+  assert.equal(cooked, substitutions + 1);
+  while (i < substitutions) {
+    var sub = arguments[i++ + 1];
+    var tail = cs[i];
+    tagged.push(sub);
+    e = e.concat(sub, tail);
+  }
+  return e;
+}
+assert.equal('-1-2-3-', tag`-${subs[0]}-${subs[1]}-${subs[2]}-`);
+assert.deepEqual(['get0', 'get1', 'get2'], log);
+assert.deepEqual([1, 2, 3], tagged);
+tagged.length = 0;
+log.length = 0;
+assert.equal('-1-', tag`-${subs[0]}-`);
+assert.deepEqual(['get0'], log);
+assert.deepEqual([1], tagged);

test/feature/TemplateLiterals/ToStringSubstitutions.js

@@ -0,0 +1,16 @@
+var a = {
+  toString: function() { return 'a'; },
+  valueOf: function() { return '-a-'; }
+};
+var b = {
+  toString: function() { return 'b'; },
+  valueOf: function() { return '-b-'; }
+};
+assert.equal('a', `${a}`);
+assert.equal('ab', `${a}${b}`);
+assert.equal('-a--b-', `${a + b}`);
+assert.equal('-a-', `${a + ''}`);
+assert.equal('1a', `1${a}`);
+assert.equal('1a2', `1${a}2`);
+assert.equal('1a2b', `1${a}2${b}`);
+assert.equal('1a2b3', `1${a}2${b}3`);

test/feature/TemplateLiterals/ToStringSustitutionOrder.js

@@ -0,0 +1,20 @@
+var subs = [];
+var log = [];
+function getter(name, value) {
+  return {
+    get: function() {
+      log.push('get' + name);
+      return value;
+    },
+    set: function(v) {
+      log.push('set' + name);
+    }
+  };
+}
+Object.defineProperties(subs, {
+  0: getter(0, 'a'),
+  1: getter(1, 'b'),
+  2: getter(2, 'c')
+});
+assert.equal('-a-b-c-', `-${subs[0]}-${subs[1]}-${subs[2]}-`);
+assert.deepEqual(['get0', 'get1', 'get2'], log);