+++ /dev/null
-/**
- * @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
- };
- }
-};
projects / dotfiles / .git / blobdiff