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, 83 insertions, 0 deletions

diff --git a/tools/node_modules/eslint/lib/rules/no-await-in-loop.js b/tools/node_modules/eslint/lib/rules/no-await-in-loop.js
new file mode 100644
index 0000000000..d1ed92b704
--- /dev/null
+++ b/tools/node_modules/eslint/lib/rules/no-await-in-loop.js
@@ -0,0 +1,83 @@
+/**
+ * @fileoverview Rule to disallow uses of await inside of loops.
+ * @author Nat Mote (nmote)
+ */
+"use strict";
+
+// Node types which are considered loops.
+const loopTypes = new Set([
+    "ForStatement",
+    "ForOfStatement",
+    "ForInStatement",
+    "WhileStatement",
+    "DoWhileStatement"
+]);
+
+/*
+ * Node types at which we should stop looking for loops. For example, it is fine to declare an async
+ * function within a loop, and use await inside of that.
+ */
+const boundaryTypes = new Set([
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "ArrowFunctionExpression"
+]);
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow `await` inside of loops",
+            category: "Possible Errors",
+            recommended: false
+        },
+        schema: []
+    },
+    create(context) {
+        return {
+            AwaitExpression(node) {
+                const ancestors = context.getAncestors();
+
+                // Reverse so that we can traverse from the deepest node upwards.
+                ancestors.reverse();
+
+                /*
+                 * Create a set of all the ancestors plus this node so that we can check
+                 * if this use of await appears in the body of the loop as opposed to
+                 * the right-hand side of a for...of, for example.
+                 */
+                const ancestorSet = new Set(ancestors).add(node);
+
+                for (let i = 0; i < ancestors.length; i++) {
+                    const ancestor = ancestors[i];
+
+                    if (boundaryTypes.has(ancestor.type)) {
+
+                        /*
+                         * Short-circuit out if we encounter a boundary type. Loops above
+                         * this do not matter.
+                         */
+                        return;
+                    }
+                    if (loopTypes.has(ancestor.type)) {
+
+                        /*
+                         * Only report if we are actually in the body or another part that gets executed on
+                         * every iteration.
+                         */
+                        if (
+                            ancestorSet.has(ancestor.body) ||
+                            ancestorSet.has(ancestor.test) ||
+                            ancestorSet.has(ancestor.update)
+                        ) {
+                            context.report({
+                                node,
+                                message: "Unexpected `await` inside a loop."
+                            });
+                            return;
+                        }
+                    }
+                }
+            }
+        };
+    }
+};