tools: move eslint from tools to tools/node_modules

This is required because we need to add the babel-eslint dependency
and it has to be able to resolve "eslint".
babel-eslint is required to support future ES features such as async
iterators and import.meta.

Refs: https://github.com/nodejs/node/pull/17755
PR-URL: https://github.com/nodejs/node/pull/17820
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

1 files changed, 156 insertions, 0 deletions

diff --git a/tools/node_modules/eslint/lib/rules/arrow-parens.js b/tools/node_modules/eslint/lib/rules/arrow-parens.js
new file mode 100644
index 0000000000..e8f8ddd8e7
--- /dev/null
+++ b/tools/node_modules/eslint/lib/rules/arrow-parens.js
@@ -0,0 +1,156 @@
+/**
+ * @fileoverview Rule to require parens in arrow function arguments.
+ * @author Jxck
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "require parentheses around arrow function arguments",
+            category: "ECMAScript 6",
+            recommended: false
+        },
+
+        fixable: "code",
+
+        schema: [
+            {
+                enum: ["always", "as-needed"]
+            },
+            {
+                type: "object",
+                properties: {
+                    requireForBlockBody: {
+                        type: "boolean"
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+
+    create(context) {
+        const message = "Expected parentheses around arrow function argument.";
+        const asNeededMessage = "Unexpected parentheses around single function argument.";
+        const asNeeded = context.options[0] === "as-needed";
+        const requireForBlockBodyMessage = "Unexpected parentheses around single function argument having a body with no curly braces";
+        const requireForBlockBodyNoParensMessage = "Expected parentheses around arrow function argument having a body with curly braces.";
+        const requireForBlockBody = asNeeded && context.options[1] && context.options[1].requireForBlockBody === true;
+
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Determines whether a arrow function argument end with `)`
+         * @param {ASTNode} node The arrow function node.
+         * @returns {void}
+         */
+        function parens(node) {
+            const isAsync = node.async;
+            const firstTokenOfParam = sourceCode.getFirstToken(node, isAsync ? 1 : 0);
+
+            /**
+             * Remove the parenthesis around a parameter
+             * @param {Fixer} fixer Fixer
+             * @returns {string} fixed parameter
+             */
+            function fixParamsWithParenthesis(fixer) {
+                const paramToken = sourceCode.getTokenAfter(firstTokenOfParam);
+
+                /*
+                 * ES8 allows Trailing commas in function parameter lists and calls
+                 * https://github.com/eslint/eslint/issues/8834
+                 */
+                const closingParenToken = sourceCode.getTokenAfter(paramToken, astUtils.isClosingParenToken);
+                const asyncToken = isAsync ? sourceCode.getTokenBefore(firstTokenOfParam) : null;
+                const shouldAddSpaceForAsync = asyncToken && (asyncToken.range[1] === firstTokenOfParam.range[0]);
+
+                return fixer.replaceTextRange([
+                    firstTokenOfParam.range[0],
+                    closingParenToken.range[1]
+                ], `${shouldAddSpaceForAsync ? " " : ""}${paramToken.value}`);
+            }
+
+            // "as-needed", { "requireForBlockBody": true }: x => x
+            if (
+                requireForBlockBody &&
+                node.params.length === 1 &&
+                node.params[0].type === "Identifier" &&
+                !node.params[0].typeAnnotation &&
+                node.body.type !== "BlockStatement" &&
+                !node.returnType
+            ) {
+                if (astUtils.isOpeningParenToken(firstTokenOfParam)) {
+                    context.report({
+                        node,
+                        message: requireForBlockBodyMessage,
+                        fix: fixParamsWithParenthesis
+                    });
+                }
+                return;
+            }
+
+            if (
+                requireForBlockBody &&
+                node.body.type === "BlockStatement"
+            ) {
+                if (!astUtils.isOpeningParenToken(firstTokenOfParam)) {
+                    context.report({
+                        node,
+                        message: requireForBlockBodyNoParensMessage,
+                        fix(fixer) {
+                            return fixer.replaceText(firstTokenOfParam, `(${firstTokenOfParam.value})`);
+                        }
+                    });
+                }
+                return;
+            }
+
+            // "as-needed": x => x
+            if (asNeeded &&
+                node.params.length === 1 &&
+                node.params[0].type === "Identifier" &&
+                !node.params[0].typeAnnotation &&
+                !node.returnType
+            ) {
+                if (astUtils.isOpeningParenToken(firstTokenOfParam)) {
+                    context.report({
+                        node,
+                        message: asNeededMessage,
+                        fix: fixParamsWithParenthesis
+                    });
+                }
+                return;
+            }
+
+            if (firstTokenOfParam.type === "Identifier") {
+                const after = sourceCode.getTokenAfter(firstTokenOfParam);
+
+                // (x) => x
+                if (after.value !== ")") {
+                    context.report({
+                        node,
+                        message,
+                        fix(fixer) {
+                            return fixer.replaceText(firstTokenOfParam, `(${firstTokenOfParam.value})`);
+                        }
+                    });
+                }
+            }
+        }
+
+        return {
+            ArrowFunctionExpression: parens
+        };
+    }
+};