| /** |
| * @fileoverview Rule to flag creation of function inside a loop |
| * @author Ilya Volodin |
| */ |
| |
| "use strict"; |
| |
| //------------------------------------------------------------------------------ |
| // Helpers |
| //------------------------------------------------------------------------------ |
| |
| /** |
| * Gets the containing loop node of a specified node. |
| * |
| * We don't need to check nested functions, so this ignores those. |
| * `Scope.through` contains references of nested functions. |
| * |
| * @param {ASTNode} node - An AST node to get. |
| * @returns {ASTNode|null} The containing loop node of the specified node, or |
| * `null`. |
| */ |
| function getContainingLoopNode(node) { |
| for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) { |
| const parent = currentNode.parent; |
| |
| switch (parent.type) { |
| case "WhileStatement": |
| case "DoWhileStatement": |
| return parent; |
| |
| case "ForStatement": |
| |
| // `init` is outside of the loop. |
| if (parent.init !== currentNode) { |
| return parent; |
| } |
| break; |
| |
| case "ForInStatement": |
| case "ForOfStatement": |
| |
| // `right` is outside of the loop. |
| if (parent.right !== currentNode) { |
| return parent; |
| } |
| break; |
| |
| case "ArrowFunctionExpression": |
| case "FunctionExpression": |
| case "FunctionDeclaration": |
| |
| // We don't need to check nested functions. |
| return null; |
| |
| default: |
| break; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Gets the containing loop node of a given node. |
| * If the loop was nested, this returns the most outer loop. |
| * |
| * @param {ASTNode} node - A node to get. This is a loop node. |
| * @param {ASTNode|null} excludedNode - A node that the result node should not |
| * include. |
| * @returns {ASTNode} The most outer loop node. |
| */ |
| function getTopLoopNode(node, excludedNode) { |
| const border = excludedNode ? excludedNode.range[1] : 0; |
| let retv = node; |
| let containingLoopNode = node; |
| |
| while (containingLoopNode && containingLoopNode.range[0] >= border) { |
| retv = containingLoopNode; |
| containingLoopNode = getContainingLoopNode(containingLoopNode); |
| } |
| |
| return retv; |
| } |
| |
| /** |
| * Checks whether a given reference which refers to an upper scope's variable is |
| * safe or not. |
| * |
| * @param {ASTNode} loopNode - A containing loop node. |
| * @param {eslint-scope.Reference} reference - A reference to check. |
| * @returns {boolean} `true` if the reference is safe or not. |
| */ |
| function isSafe(loopNode, reference) { |
| const variable = reference.resolved; |
| const definition = variable && variable.defs[0]; |
| const declaration = definition && definition.parent; |
| const kind = (declaration && declaration.type === "VariableDeclaration") |
| ? declaration.kind |
| : ""; |
| |
| // Variables which are declared by `const` is safe. |
| if (kind === "const") { |
| return true; |
| } |
| |
| /* |
| * Variables which are declared by `let` in the loop is safe. |
| * It's a different instance from the next loop step's. |
| */ |
| if (kind === "let" && |
| declaration.range[0] > loopNode.range[0] && |
| declaration.range[1] < loopNode.range[1] |
| ) { |
| return true; |
| } |
| |
| /* |
| * WriteReferences which exist after this border are unsafe because those |
| * can modify the variable. |
| */ |
| const border = getTopLoopNode( |
| loopNode, |
| (kind === "let") ? declaration : null |
| ).range[0]; |
| |
| /** |
| * Checks whether a given reference is safe or not. |
| * The reference is every reference of the upper scope's variable we are |
| * looking now. |
| * |
| * It's safeafe if the reference matches one of the following condition. |
| * - is readonly. |
| * - doesn't exist inside a local function and after the border. |
| * |
| * @param {eslint-scope.Reference} upperRef - A reference to check. |
| * @returns {boolean} `true` if the reference is safe. |
| */ |
| function isSafeReference(upperRef) { |
| const id = upperRef.identifier; |
| |
| return ( |
| !upperRef.isWrite() || |
| variable.scope.variableScope === upperRef.from.variableScope && |
| id.range[0] < border |
| ); |
| } |
| |
| return Boolean(variable) && variable.references.every(isSafeReference); |
| } |
| |
| //------------------------------------------------------------------------------ |
| // Rule Definition |
| //------------------------------------------------------------------------------ |
| |
| module.exports = { |
| meta: { |
| type: "suggestion", |
| |
| docs: { |
| description: "disallow function declarations that contain unsafe references inside loop statements", |
| category: "Best Practices", |
| recommended: false, |
| url: "https://eslint.org/docs/rules/no-loop-func" |
| }, |
| |
| schema: [], |
| |
| messages: { |
| unsafeRefs: "Function declared in a loop contains unsafe references to variable(s) {{ varNames }}." |
| } |
| }, |
| |
| create(context) { |
| |
| /** |
| * Reports functions which match the following condition: |
| * |
| * - has a loop node in ancestors. |
| * - has any references which refers to an unsafe variable. |
| * |
| * @param {ASTNode} node The AST node to check. |
| * @returns {boolean} Whether or not the node is within a loop. |
| */ |
| function checkForLoops(node) { |
| const loopNode = getContainingLoopNode(node); |
| |
| if (!loopNode) { |
| return; |
| } |
| |
| const references = context.getScope().through; |
| const unsafeRefs = references.filter(r => !isSafe(loopNode, r)).map(r => r.identifier.name); |
| |
| if (unsafeRefs.length > 0) { |
| context.report({ |
| node, |
| messageId: "unsafeRefs", |
| data: { varNames: `'${unsafeRefs.join("', '")}'` } |
| }); |
| } |
| } |
| |
| return { |
| ArrowFunctionExpression: checkForLoops, |
| FunctionExpression: checkForLoops, |
| FunctionDeclaration: checkForLoops |
| }; |
| } |
| }; |