Update: no-useless-rest-spread supports for properties (stage 3).

Author: mysticatea

docs/rules/no-useless-rest-spread.md

@@ -10,9 +10,11 @@ Examples of **incorrect** code for this rule:
 /*eslint no-useless-rest-spread: "error"*/
 
 let list = [a, ...[b, c], d]
+let obj = {a, ...{b, c}, d}
 foo(...[a, b, c])
 
 let [a, b, ...[c, d]] = list;
+let {a, b, ...{c, d}} = obj;
 function foo(a, b, ...[c, d]) {
 }
 ```
@@ -23,9 +25,11 @@ Examples of **correct** code for this rule:
 /*eslint no-useless-rest-spread: "error"*/
 
 let list = [a, b, c, d]
+let obj = {a, b, c, d}
 foo(a, b, c)
 
 let [a, b, c, d] = list;
+let {a, b, c, d} = obj;
 function foo(a, b, c, d) {
 }
 ```

lib/rules/no-useless-rest-spread.js

@@ -2,7 +2,6 @@
  * @fileoverview Rule to disallow unnecessary spread operators.
  * @author Toru Nagashima
  */
-
 "use strict"
 
 //------------------------------------------------------------------------------
@@ -61,6 +60,46 @@ module.exports = {
                     })
                 }
             },
+
+            SpreadProperty(node) {
+                if (node.argument.type === "ObjectExpression") {
+                    context.report({
+                        node,
+                        message: "Unexpected a spread property.",
+                        fix: defineFixer(node),
+                    })
+                }
+            },
+
+            RestProperty(node) {
+                if (node.argument.type === "ObjectPattern") {
+                    context.report({
+                        node,
+                        message: "Unexpected a rest property.",
+                        fix: defineFixer(node),
+                    })
+                }
+            },
+
+            ExperimentalSpreadProperty(node) {
+                if (node.argument.type === "ObjectExpression") {
+                    context.report({
+                        node,
+                        message: "Unexpected a spread property.",
+                        fix: defineFixer(node),
+                    })
+                }
+            },
+
+            ExperimentalRestProperty(node) {
+                if (node.argument.type === "ObjectPattern") {
+                    context.report({
+                        node,
+                        message: "Unexpected a rest property.",
+                        fix: defineFixer(node),
+                    })
+                }
+            },
         }
     },
 }

tests/lib/rules/no-useless-rest-spread.js

@@ -15,36 +15,58 @@ const RuleTester = require("eslint").RuleTester
 // Tests
 //------------------------------------------------------------------------------
 
-const ruleTester = new RuleTester()
+const ruleTester = new RuleTester({
+    parserOptions: {
+        ecmaVersion: 2015,
+        ecmaFeatures: {experimentalObjectRestSpread: true},
+    },
+})
 
 ruleTester.run("no-useless-rest-spread", rule, {
     valid: [
-        {code: "let list = [...a, ...b]", env: {es6: true}},
-        {code: "foo(...a, ...b)", env: {es6: true}},
-        {code: "let [a, b, c, ...d] = obj", env: {es6: true}},
-        {code: "function foo(a, b, c, ...d) {}", env: {es6: true}},
+        "let list = [...a, ...b]",
+        "foo(...a, ...b)",
+        "let [a, b, c, ...d] = obj",
+        "function foo(a, b, c, ...d) {}",
+        "let obj = {...a, ...b}",
+        "let {a, ...b} = obj",
+
+        // those are invalid. I'll separate to another rule.
+        "let list = [...{a}]",
+        "let obj = {...[a]}",
     ],
     invalid: [
         {
             code: "let list = [...[x, y, x], ...b]",
             output: "let list = [x, y, x, ...b]",
-            env: {es6: true},
             errors: ["Unexpected a spread operator."],
         },
         {
             code: "foo(...a, ...[x, y, x])",
             output: "foo(...a, x, y, x)",
-            env: {es6: true},
             errors: ["Unexpected a spread operator."],
         },
         {
             code: "let [a, ...[b, c, ...d]] = obj",
             output: "let [a, b, c, ...d] = obj",
-            env: {es6: true},
             errors: ["Unexpected a rest operator."],
         },
-
-        // Acorn cannot parse this
-        // {code: "function foo(a, ...[b, c, ...d]) {}", env: {es6: true}, errors: ["Unexpected a rest operator."]},
+        // Espree threw a syntax error.
+        // {
+        //     code: "function foo(a, ...[b, c, ...d]) {}",
+        //     output: "function foo(a, ...b, c, ...d) {}",
+        //     errors: ["Unexpected a rest operator."],
+        // },
+        {
+            code: "let obj = {...{x, y, x}, ...b}",
+            output: "let obj = {x, y, x, ...b}",
+            errors: ["Unexpected a spread property."],
+        },
+        // Espree threw a syntax error.
+        // {
+        //     code: "let {a, ...{b, c, ...d}} = obj",
+        //     output: "let {a, b, c, ...d} = obj",
+        //     errors: ["Unexpected a rest property."],
+        // },
     ],
 })