tools: update ESLint to 5.9.0

Update ESLint to 5.9.0.

PR-URL: https://github.com/nodejs/node/pull/24280
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>

1 files changed, 101 insertions, 27 deletions

diff --git a/tools/node_modules/eslint/lib/rules/id-match.js b/tools/node_modules/eslint/lib/rules/id-match.js
index 608ef17d11..4755c779ca 100644
--- a/tools/node_modules/eslint/lib/rules/id-match.js
+++ b/tools/node_modules/eslint/lib/rules/id-match.js
@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require identifiers to match a specified regular expression",
             category: "Stylistic Issues",
@@ -27,6 +29,12 @@ module.exports = {
                 properties: {
                     properties: {
                         type: "boolean"
+                    },
+                    onlyDeclarations: {
+                        type: "boolean"
+                    },
+                    ignoreDestructuring: {
+                        type: "boolean"
                     }
                 }
             }
@@ -36,15 +44,25 @@ module.exports = {
     create(context) {
 
         //--------------------------------------------------------------------------
-        // Helpers
+        // Options
         //--------------------------------------------------------------------------
-
         const pattern = context.options[0] || "^.+$",
             regexp = new RegExp(pattern);
 
         const options = context.options[1] || {},
             properties = !!options.properties,
-            onlyDeclarations = !!options.onlyDeclarations;
+            onlyDeclarations = !!options.onlyDeclarations,
+            ignoreDestructuring = !!options.ignoreDestructuring;
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        // contains reported nodes to avoid reporting twice on destructuring with shorthand notation
+        const reported = new Map();
+        const ALLOWED_PARENT_TYPES = new Set(["CallExpression", "NewExpression"]);
+        const DECLARATION_TYPES = new Set(["FunctionDeclaration", "VariableDeclarator"]);
+        const IMPORT_TYPES = new Set(["ImportSpecifier", "ImportNamespaceSpecifier", "ImportDefaultSpecifier"]);
 
         /**
          * Checks if a string matches the provided pattern
@@ -57,6 +75,26 @@ module.exports = {
         }
 
         /**
+         * Checks if a parent of a node is an ObjectPattern.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} if the node is inside an ObjectPattern
+         * @private
+         */
+        function isInsideObjectPattern(node) {
+            let { parent } = node;
+
+            while (parent) {
+                if (parent.type === "ObjectPattern") {
+                    return true;
+                }
+
+                parent = parent.parent;
+            }
+
+            return false;
+        }
+
+        /**
          * Verifies if we should report an error or not based on the effective
          * parent node and the identifier name.
          * @param {ASTNode} effectiveParent The effective parent node of the node to be reported
@@ -64,9 +102,8 @@ module.exports = {
          * @returns {boolean} whether an error should be reported or not
          */
         function shouldReport(effectiveParent, name) {
-            return effectiveParent.type !== "CallExpression" &&
-                effectiveParent.type !== "NewExpression" &&
-                isInvalid(name);
+            return (!onlyDeclarations || DECLARATION_TYPES.has(effectiveParent.type)) &&
+                !ALLOWED_PARENT_TYPES.has(effectiveParent.type) && isInvalid(name);
         }
 
         /**
@@ -76,14 +113,17 @@ module.exports = {
          * @private
          */
         function report(node) {
-            context.report({
-                node,
-                message: "Identifier '{{name}}' does not match the pattern '{{pattern}}'.",
-                data: {
-                    name: node.name,
-                    pattern
-                }
-            });
+            if (!reported.has(node)) {
+                context.report({
+                    node,
+                    message: "Identifier '{{name}}' does not match the pattern '{{pattern}}'.",
+                    data: {
+                        name: node.name,
+                        pattern
+                    }
+                });
+                reported.set(node, true);
+            }
         }
 
         return {
@@ -106,36 +146,70 @@ module.exports = {
                             report(node);
                         }
 
-                    // Report AssignmentExpressions only if they are the left side of the assignment
+                    // Report AssignmentExpressions left side's assigned variable id
                     } else if (effectiveParent.type === "AssignmentExpression" &&
-                        (effectiveParent.right.type !== "MemberExpression" ||
                         effectiveParent.left.type === "MemberExpression" &&
-                        effectiveParent.left.property.name === name)) {
+                        effectiveParent.left.property.name === node.name) {
+                        if (isInvalid(name)) {
+                            report(node);
+                        }
+
+                    // Report AssignmentExpressions only if they are the left side of the assignment
+                    } else if (effectiveParent.type === "AssignmentExpression" && effectiveParent.right.type !== "MemberExpression") {
                         if (isInvalid(name)) {
                             report(node);
                         }
                     }
 
-                } else if (parent.type === "Property") {
+                /*
+                 * Properties have their own rules, and
+                 * AssignmentPattern nodes can be treated like Properties:
+                 * e.g.: const { no_camelcased = false } = bar;
+                 */
+                } else if (parent.type === "Property" || parent.type === "AssignmentPattern") {
+
+                    if (parent.parent && parent.parent.type === "ObjectPattern") {
+                        if (parent.shorthand && parent.value.left && isInvalid(name)) {
+
+                            report(node);
+                        }
+
+                        const assignmentKeyEqualsValue = parent.key.name === parent.value.name;
 
-                    if (!properties || parent.key.name !== name) {
+                        // prevent checking righthand side of destructured object
+                        if (!assignmentKeyEqualsValue && parent.key === node) {
+                            return;
+                        }
+
+                        const valueIsInvalid = parent.value.name && isInvalid(name);
+
+                        // ignore destructuring if the option is set, unless a new identifier is created
+                        if (valueIsInvalid && !(assignmentKeyEqualsValue && ignoreDestructuring)) {
+                            report(node);
+                        }
+                    }
+
+                    // never check properties or always ignore destructuring
+                    if (!properties || (ignoreDestructuring && isInsideObjectPattern(node))) {
                         return;
                     }
 
-                    if (shouldReport(effectiveParent, name)) {
+                    // don't check right hand side of AssignmentExpression to prevent duplicate warnings
+                    if (parent.right !== node && shouldReport(effectiveParent, name)) {
                         report(node);
                     }
 
-                } else {
-                    const isDeclaration = effectiveParent.type === "FunctionDeclaration" || effectiveParent.type === "VariableDeclarator";
+                // Check if it's an import specifier
+                } else if (IMPORT_TYPES.has(parent.type)) {
 
-                    if (onlyDeclarations && !isDeclaration) {
-                        return;
-                    }
-
-                    if (shouldReport(effectiveParent, name)) {
+                    // Report only if the local imported identifier is invalid
+                    if (parent.local && parent.local.name === node.name && isInvalid(name)) {
                         report(node);
                     }
+
+                // Report anything that is invalid that isn't a CallExpression
+                } else if (shouldReport(effectiveParent, name)) {
+                    report(node);
                 }
             }