Add support for destructuring to no-nonstandard-*-properties rules (#220)

Author: ota-meshi

lib/util/define-nonstandard-properties-handler/index.js

@@ -36,35 +36,95 @@ function defineNonstandardPropertiesHandler(
         }
         map[READ] = true
     }
+    const sourceCode = getSourceCode(context)
+
+    /**
+     * @param {import("estree").ObjectPattern} node
+     */
+    function* extractNonstandardProperties(node) {
+        for (const prop of node.properties) {
+            if (prop.type !== "Property") {
+                continue
+            }
+            const propertyName = getPropertyName(
+                prop,
+                sourceCode.getScope(node),
+            )
+            if (propertyName == null || propertyNamesSet.has(propertyName)) {
+                continue
+            }
+            yield { node: prop, propertyName }
+        }
+    }
+
+    /**
+     * @param {import("estree").Node} node
+     * @param {string[]} path
+     * @param {string} propertyName
+     */
+    function report(node, path, propertyName) {
+        context.report({
+            node,
+            messageId: "forbidden",
+            data: { name: [...path, propertyName].join(".") },
+        })
+    }
+
     return {
         "Program:exit"(program) {
-            const sourceCode = getSourceCode(context)
             const tracker = new ReferenceTracker(sourceCode.getScope(program))
             for (const { node, path } of tracker.iterateGlobalReferences(
                 traceMap,
             )) {
-                if (
-                    node.parent.type !== "MemberExpression" ||
-                    node.parent.object !== node
-                ) {
+                /** @type {import("estree").Node | null} */
+                const parent = node.parent
+                if (!parent) {
                     continue
                 }
-                const propertyName = getPropertyName(
-                    node.parent,
-                    sourceCode.getScope(node),
-                )
-                if (
-                    propertyName == null ||
-                    propertyNamesSet.has(propertyName)
-                ) {
+                if (parent.type === "MemberExpression") {
+                    if (parent.object !== node) {
+                        continue
+                    }
+                    const propertyName = getPropertyName(
+                        parent,
+                        sourceCode.getScope(node),
+                    )
+                    if (
+                        propertyName == null ||
+                        propertyNamesSet.has(propertyName)
+                    ) {
+                        continue
+                    }
+                    report(parent, path, propertyName)
+                } else if (parent.type === "VariableDeclarator") {
+                    if (
+                        parent.init !== node ||
+                        parent.id.type !== "ObjectPattern"
+                    ) {
+                        continue
+                    }
+                    for (const {
+                        node: reportNode,
+                        propertyName,
+                    } of extractNonstandardProperties(parent.id)) {
+                        report(reportNode, path, propertyName)
+                    }
+                } else if (parent.type === "AssignmentExpression") {
+                    if (
+                        parent.right !== node ||
+                        parent.left.type !== "ObjectPattern"
+                    ) {
+                        continue
+                    }
+                    for (const {
+                        node: reportNode,
+                        propertyName,
+                    } of extractNonstandardProperties(parent.left)) {
+                        report(reportNode, path, propertyName)
+                    }
+                } else {
                     continue
                 }
-
-                context.report({
-                    node,
-                    messageId: "forbidden",
-                    data: { name: [...path, propertyName].join(".") },
-                })
             }
         },
     }

tests/lib/rules/no-nonstandard-array-properties.js

@@ -22,5 +22,13 @@ new RuleTester().run("no-nonstandard-array-properties", rule, {
             code: "Array.bar",
             errors: ["Non-standard 'Array.bar' property is forbidden."],
         },
+        {
+            code: "const { foo } = Array;",
+            errors: ["Non-standard 'Array.foo' property is forbidden."],
+        },
+        {
+            code: ";({ foo } = Array);",
+            errors: ["Non-standard 'Array.foo' property is forbidden."],
+        },
     ],
 })