use type inferrence to work out whether to wrap template literals with the String constructor

src/babel/transformation/transformers/es6/spec.template-literals.js

@@ -1,7 +1,8 @@
 import * as t from "../../../types";
 
 export var metadata = {
-  optional: true
+  optional: true,
+  group: "builtin-pre"
 };
 
 export function TemplateLiteral(node, parent, scope, file) {

src/babel/transformation/transformers/es6/template-literals.js

@@ -1,9 +1,24 @@
 import * as t from "../../../types";
 
-var buildBinaryExpression = function (left, right) {
-  return t.binaryExpression("+", left, right);
+export var metadata = {
+  group: "builtin-pre"
 };
 
+function buildBinaryExpression(left, right) {
+  var node = t.binaryExpression("+", left, right);
+  node._templateLiteralProduced = true;
+  return node;
+}
+
+function crawl(path) {
+  if (path.is("_templateLiteralProduced")) {
+    crawl(path.get("left"));
+    crawl(path.get("right"));
+  } else if (!path.isTypeAnnotationGeneric("String") && !path.isTypeAnnotationGeneric("Number")) {
+    path.replaceWith(t.callExpression(t.identifier("String"), [path.node]));
+  }
+}
+
 export function TaggedTemplateExpression(node, parent, scope, file) {
   var quasi = node.quasi;
   var args  = [];
@@ -11,8 +26,7 @@ export function TaggedTemplateExpression(node, parent, scope, file) {
   var strings = [];
   var raw     = [];
 
-  for (var i = 0; i < quasi.quasis.length; i++) {
-    var elem = quasi.quasis[i];
+  for (var elem of (quasi.quasis: Array)) {
     strings.push(t.literal(elem.value.cooked));
     raw.push(t.literal(elem.value.raw));
   }
@@ -31,11 +45,8 @@ export function TaggedTemplateExpression(node, parent, scope, file) {
 
 export function TemplateLiteral(node, parent, scope, file) {
   var nodes = [];
-  var i;
-
-  for (i = 0; i < node.quasis.length; i++) {
-    var elem = node.quasis[i];
 
+  for (let elem of (node.quasis: Array)) {
     nodes.push(t.literal(elem.value.cooked));
 
     var expr = node.expressions.shift();
@@ -49,11 +60,12 @@ export function TemplateLiteral(node, parent, scope, file) {
 
     var root = buildBinaryExpression(nodes.shift(), nodes.shift());
 
-    for (i = 0; i < nodes.length; i++) {
-      root = buildBinaryExpression(root, nodes[i]);
+    for (let node of (nodes: Array)) {
+      root = buildBinaryExpression(root, node);
     }
 
-    return root;
+    this.replaceWith(root);
+    //crawl(this);
   } else {
     return nodes[0];
   }

src/babel/transformation/transformers/index.js

@@ -13,6 +13,8 @@ export default {
   "minification.deadCodeElimination":      require("./minification/dead-code-elimination"),
   _modules:                                require("./internal/modules"),
   "spec.functionName":                     require("./spec/function-name"),
+  "es6.spec.templateLiterals":             require("./es6/spec.template-literals"),
+  "es6.templateLiterals":                  require("./es6/template-literals"),
 
   //- builtin-basic
   // this is where the bulk of the ES6 transformations take place, none of them require traversal state
@@ -34,8 +36,6 @@ export default {
   "es6.objectSuper":                       require("./es6/object-super"),
   "es7.objectRestSpread":                  require("./es7/object-rest-spread"),
   "es7.exponentiationOperator":            require("./es7/exponentiation-operator"),
-  "es6.spec.templateLiterals":             require("./es6/spec.template-literals"),
-  "es6.templateLiterals":                  require("./es6/template-literals"),
   "es5.properties.mutators":               require("./es5/properties.mutators"),
   "es6.properties.shorthand":              require("./es6/properties.shorthand"),
   "es6.properties.computed":               require("./es6/properties.computed"),