New: prefer-destructuring rule (fixes #6053)

conf/eslint.json

@@ -204,6 +204,7 @@
         "padded-blocks": "off",
         "prefer-arrow-callback": "off",
         "prefer-const": "off",
+        "prefer-destructuring": "off",
         "prefer-numeric-literals": "off",
         "prefer-reflect": "off",
         "prefer-rest-params": "off",

docs/rules/prefer-destructuring.md

@@ -0,0 +1,61 @@
+# Prefer destructuring from arrays and objects (prefer-destructuring)
+
+With JavaScript ES6, a new syntax was added for creating variables from an array index of object property, called [destructuring](#further-reading).  This rule enforces usage of destructuring instead of accessing a property through a member expression.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```javascript
+// With `array` enabled
+var foo = array[0];
+
+// With `object` enabled
+var foo = object.foo;
+var foo = object['foo'];
+```
+
+Examples of **correct** code for this rule:
+
+```javascript
+// With `array` enabled
+var [ foo ] = array;
+
+// With `object` enabled
+var { foo } = object;
+```
+
+### Options
+
+This rule takes two properties, `array` and `object`, which can be used to turn on or off the destructuring requirement for each of those types independently.  By default, both are `true`.  If you want to change the behavior, you can configure the rule like so:
+
+```json
+{
+  "rules": {
+    "prefer-destructuring": ["error", {
+      "array": true,
+      "object": true
+    }]
+  }
+}
+```
+
+## When Not To Use It
+
+If you want to be able to access array indices or object properties directly, you can either configure the rule to your tastes or disable the rule entirely.
+
+Additionally, if you intend to access large array indices directly, like:
+
+```javascript
+var foo = array[100];
+```
+
+Then the `array` part of this rule is not recommended, as destructuring does not match this use case very well.
+
+
+## Further Reading
+
+If you want to learn more about destructuring, check out the links below:
+
+- [Destructuring Assignment (MDN)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment)
+- [Destructuring and parameter handling in ECMAScript 6 (2ality blog)](http://www.2ality.com/2015/01/es6-destructuring.html)

lib/rules/prefer-destructuring.js

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview Prefer destructuring from arrays and objects
+ * @author Alex LaFroscia
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "require destructuring from arrays and/or objects",
+            category: "ECMAScript 6",
+            recommended: false
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    array: {
+                        type: "boolean"
+                    },
+                    object: {
+                        type: "boolean"
+                    }
+                },
+                additionalProperties: false
+            },
+            {
+                type: "object",
+                properties: {
+                    requireRenaming: {
+                        type: "boolean"
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    create(context) {
+
+        let checkArrays = true;
+        let checkObjects = true;
+        let requireRenaming = true;
+        const enabledTypes = context.options[0];
+        const additionalOptions = context.options[1];
+
+        if (enabledTypes) {
+            if (typeof enabledTypes.array !== "undefined") {
+                checkArrays = enabledTypes.array;
+            }
+
+            if (typeof enabledTypes.object !== "undefined") {
+                checkObjects = enabledTypes.object;
+            }
+        }
+
+        if (additionalOptions) {
+            if (typeof additionalOptions.requireRenaming !== "undefined") {
+                requireRenaming = additionalOptions.requireRenaming;
+            }
+        }
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        /**
+         * Determines if the given node node is accessing an array index
+         *
+         * This is used to differentiate array index access from object property
+         * access.
+         *
+         * @param {ASTNode} node the node to evaluate
+         * @returns {boolean} whether or not the node is an integer
+         */
+        function isArrayIndexAccess(node) {
+            return Number.isInteger(node.property.value);
+        }
+
+        /**
+         * Check that the `prefer-destructuring` rules are followed based on the
+         * given left- and right-hand side of the assignment.
+         *
+         * Pulled out into a separate method so that VariableDeclarators and
+         * AssignmentExpressions can share the same verification logic.
+         *
+         * @param {ASTNode} leftNode the left-hand side of the assignment
+         * @param {ASTNode} rightNode the right-hand side of the assignment
+         * @param {ASTNode} reportNode the node to report the error on
+         * @returns {void}
+         */
+        function performCheck(leftNode, rightNode, reportNode) {
+            if (rightNode.type !== "MemberExpression") {
+                return;
+            }
+
+            if (checkArrays && isArrayIndexAccess(rightNode)) {
+                context.report({ node: reportNode, message: "Use array destructuring" });
+                return;
+            }
+
+            if (checkObjects && !isArrayIndexAccess(rightNode)) {
+                const property = rightNode.property;
+
+                if (requireRenaming && !rightNode.computed) {
+                    context.report({ node: reportNode, message: "Use object destructuring" });
+                    return;
+                }
+
+                if (property.type === "Literal" && leftNode.name === property.value) {
+                    context.report({ node: reportNode, message: "Use object destructuring" });
+                }
+
+                if (property.type === "Identifier" && leftNode.name === property.name) {
+                    context.report({ node: reportNode, message: "Use object destructuring" });
+                }
+            }
+        }
+
+        /**
+         * Check if a given variable declarator is coming from an property access
+         * that should be using destructuring instead
+         *
+         * @param {ASTNode} node the variable declarator to check
+         * @returns {void}
+         */
+        function checkVariableDeclarator(node) {
+
+            // Skip if variable is declared without assignment
+            if (!node.init) {
+                return;
+            }
+
+            // We only care about member expressions past this point
+            if (node.init.type !== "MemberExpression") {
+                return;
+            }
+
+            performCheck(node.id, node.init, node);
+        }
+
+        /**
+         * Run the `prefer-destructuring` check on an AssignmentExpression
+         *
+         * @param {ASTNode} node the AssignmentExpression node
+         * @returns {void}
+         */
+        function checkAssigmentExpression(node) {
+            performCheck(node.left, node.right, node);
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            VariableDeclarator: checkVariableDeclarator,
+            AssignmentExpression: checkAssigmentExpression
+        };
+    }
+};

tests/lib/rules/prefer-destructuring.js

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Prefer destructuring from arrays and objects
+ * @author Alex LaFroscia
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const rule = require("../../../lib/rules/prefer-destructuring"),
+    RuleTester = require("../../../lib/testers/rule-tester");
+
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
+
+ruleTester.run("prefer-destructuring", rule, {
+    valid: [
+        {
+            code: "var [foo] = array;"
+        },
+        {
+            code: "var { foo } = object;"
+        },
+        {
+
+            // Ensure that this doesn't break variable declarating without assignment
+            code: "var foo;"
+        },
+        {
+            code: "var foo = object.bar;",
+            options: [{ object: true }, { requireRenaming: false }]
+        },
+        {
+            code: "var foo = object['bar'];",
+            options: [{ object: true }, { requireRenaming: false }]
+        },
+        {
+            code: "var { bar: foo } = object;",
+            options: [{ object: true }, { requireRenaming: true }]
+        },
+        {
+            code: "var foo = object[bar];",
+            options: [{ object: true }, { requireRenaming: true }]
+        },
+        {
+            code: "var foo = array[0];",
+            options: [{ array: false }]
+        },
+        {
+            code: "var foo = object.foo;",
+            options: [{ object: false }]
+        },
+        {
+            code: "var foo = object['foo'];",
+            options: [{ object: false }]
+        },
+        {
+            code: "({ foo } = object);"
+        },
+        {
+            code: "[foo] = array;"
+        }
+    ],
+
+    invalid: [
+        {
+            code: "var foo = array[0];",
+            errors: [{
+                message: "Use array destructuring",
+                type: "VariableDeclarator"
+            }]
+        },
+        {
+            code: "foo = array[0];",
+            errors: [{
+                message: "Use array destructuring",
+                type: "AssignmentExpression"
+            }]
+        },
+        {
+            code: "var foo = array.foo;",
+            errors: [{
+                message: "Use object destructuring",
+                type: "VariableDeclarator"
+            }]
+        },
+        {
+            code: "var foo = array.bar;",
+            options: [{ object: true }, { requireRenaming: true }],
+            errors: [{
+                message: "Use object destructuring",
+                type: "VariableDeclarator"
+            }]
+        },
+        {
+            code: "var foo = array['foo'];",
+            errors: [{
+                message: "Use object destructuring",
+                type: "VariableDeclarator"
+            }]
+        },
+        {
+            code: "foo = array.foo;",
+            errors: [{
+                message: "Use object destructuring",
+                type: "AssignmentExpression"
+            }]
+        },
+        {
+            code: "foo = array['foo'];",
+            errors: [{
+                message: "Use object destructuring",
+                type: "AssignmentExpression"
+            }]
+        }
+    ]
+});