Update: no-implicit-coercion checks TemplateLiterals (fixes #7062) (#…

…7121)
eslint · Sep 13, 2016 · a876673 · a876673
1 parent 8db4f0c
commit a876673
Show file tree

Hide file tree

Showing 3 changed files with 55 additions and 14 deletions.
diff --git a/docs/rules/no-implicit-coercion.md b/docs/rules/no-implicit-coercion.md
@@ -13,7 +13,7 @@ var b = ~foo.indexOf(".");
 var n = +foo;
 var n = 1 * foo;
 var s = "" + foo;
-foo += "";
+foo += ``;
 ```
 
 Those can be replaced with the following code:
@@ -94,7 +94,9 @@ Examples of **incorrect** code for the default `{ "string": true }` option:
 /*eslint no-implicit-coercion: "error"*/
 
 var s = "" + foo;
+var s = `` + foo;
 foo += "";
+foo += ``;
 ```
 
 Examples of **correct** code for the default `{ "string": true }` option:
@@ -103,6 +105,7 @@ Examples of **correct** code for the default `{ "string": true }` option:
 /*eslint no-implicit-coercion: "error"*/
 
 var s = String(foo);
+foo = String(foo);
 ```
 
 ### allow

diff --git a/lib/rules/no-implicit-coercion.js b/lib/rules/no-implicit-coercion.js
@@ -107,24 +107,14 @@ function getNonNumericOperand(node) {
     return null;
 }
 
-/**
- * Checks whether a node is a string literal or not.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} Whether or not the passed in node is a
- * string literal or not.
- */
-function isStringLiteral(node) {
-    return astUtils.isStringLiteral(node) && node.type !== "TemplateLiteral";
-}
-
 /**
  * Checks whether a node is an empty string literal or not.
  * @param {ASTNode} node The node to check.
  * @returns {boolean} Whether or not the passed in node is an
  * empty string literal or not.
  */
 function isEmptyString(node) {
-    return isStringLiteral(node) && node.value === "";
+    return astUtils.isStringLiteral(node) && (node.value === "" || (node.type === "TemplateLiteral" && node.quasis.length === 1 && node.quasis[0].value.cooked === ""));
 }
 
 /**
@@ -134,8 +124,8 @@ function isEmptyString(node) {
  */
 function isConcatWithEmptyString(node) {
     return node.operator === "+" && (
-        (isEmptyString(node.left) && !isStringLiteral(node.right)) ||
-        (isEmptyString(node.right) && !isStringLiteral(node.left))
+        (isEmptyString(node.left) && !astUtils.isStringLiteral(node.right)) ||
+        (isEmptyString(node.right) && !astUtils.isStringLiteral(node.left))
     );
 }
 

diff --git a/tests/lib/rules/no-implicit-coercion.js b/tests/lib/rules/no-implicit-coercion.js
@@ -63,6 +63,8 @@ ruleTester.run("no-implicit-coercion", rule, {
         {code: "1234*1*parseInt(foo)*bar"},
         {code: "0 + foo"},
         {code: "~foo.bar()"},
+        {code: "foo + 'bar'" },
+        {code: "foo + `${bar}`", parserOptions: { ecmaVersion: 6 } },
 
         {code: "!!foo", options: [{boolean: false}]},
         {code: "~foo.indexOf(1)", options: [{boolean: false}]},
@@ -79,8 +81,13 @@ ruleTester.run("no-implicit-coercion", rule, {
 
         // https://github.com/eslint/eslint/issues/7057
         {code: "'' + 'foo'"},
+        {code: "`` + 'foo'", parserOptions: { ecmaVersion: 6 } },
+        {code: "'' + `${foo}`", parserOptions: { ecmaVersion: 6 } },
         {code: "'foo' + ''"},
+        {code: "'foo' + ``", parserOptions: { ecmaVersion: 6 } },
+        {code: "`${foo}` + ''", parserOptions: { ecmaVersion: 6 } },
         {code: "foo += 'bar'"},
+        {code: "foo += `${bar}`", parserOptions: { ecmaVersion: 6 } },
         {code: "+42"}
     ],
     invalid: [
@@ -134,21 +141,56 @@ ruleTester.run("no-implicit-coercion", rule, {
             errors: [{message: "use `String(foo)` instead.", type: "BinaryExpression"}],
             output: "String(foo)"
         },
+        {
+            code: "``+foo",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{message: "use `String(foo)` instead.", type: "BinaryExpression"}],
+            output: "String(foo)"
+        },
         {
             code: "foo+\"\"",
             errors: [{message: "use `String(foo)` instead.", type: "BinaryExpression"}],
             output: "String(foo)"
         },
+        {
+            code: "foo+``",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{message: "use `String(foo)` instead.", type: "BinaryExpression"}],
+            output: "String(foo)"
+        },
         {
             code: "\"\"+foo.bar",
             errors: [{message: "use `String(foo.bar)` instead.", type: "BinaryExpression"}],
             output: "String(foo.bar)"
         },
+        {
+            code: "``+foo.bar",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{message: "use `String(foo.bar)` instead.", type: "BinaryExpression"}],
+            output: "String(foo.bar)"
+        },
+        {
+            code: "foo.bar+\"\"",
+            errors: [{message: "use `String(foo.bar)` instead.", type: "BinaryExpression"}],
+            output: "String(foo.bar)"
+        },
+        {
+            code: "foo.bar+``",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{message: "use `String(foo.bar)` instead.", type: "BinaryExpression"}],
+            output: "String(foo.bar)"
+        },
         {
             code: "foo += \"\"",
             errors: [{message: "use `foo = String(foo)` instead.", type: "AssignmentExpression"}],
             output: "foo = String(foo)"
         },
+        {
+            code: "foo += ``",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{message: "use `foo = String(foo)` instead.", type: "AssignmentExpression"}],
+            output: "foo = String(foo)"
+        },
         {
             code: "var a = !!foo", options: [{boolean: true, allow: ["~"]}],
             errors: [{message: "use `Boolean(foo)` instead.", type: "UnaryExpression"}],
@@ -173,6 +215,12 @@ ruleTester.run("no-implicit-coercion", rule, {
             code: "var a = \"\" + foo", options: [{boolean: true, allow: ["*"]}],
             errors: [{message: "use `String(foo)` instead.", type: "BinaryExpression"}],
             output: "var a = String(foo)"
+        },
+        {
+            code: "var a = `` + foo", options: [{boolean: true, allow: ["*"]}],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{message: "use `String(foo)` instead.", type: "BinaryExpression"}],
+            output: "var a = String(foo)"
         }
     ]
 });