+++ /dev/null
-/**
- * @fileoverview Rule to disallow use of unmodified expressions in loop conditions
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const Traverser = require("../shared/traverser"),
- astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const SENTINEL_PATTERN = /(?:(?:Call|Class|Function|Member|New|Yield)Expression|Statement|Declaration)$/u;
-const LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/u; // for-in/of statements don't have `test` property.
-const GROUP_PATTERN = /^(?:BinaryExpression|ConditionalExpression)$/u;
-const SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/u;
-const DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/u;
-
-/**
- * @typedef {Object} LoopConditionInfo
- * @property {eslint-scope.Reference} reference - The reference.
- * @property {ASTNode} group - BinaryExpression or ConditionalExpression nodes
- * that the reference is belonging to.
- * @property {Function} isInLoop - The predicate which checks a given reference
- * is in this loop.
- * @property {boolean} modified - The flag that the reference is modified in
- * this loop.
- */
-
-/**
- * Checks whether or not a given reference is a write reference.
- * @param {eslint-scope.Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is a write reference.
- */
-function isWriteReference(reference) {
- if (reference.init) {
- const def = reference.resolved && reference.resolved.defs[0];
-
- if (!def || def.type !== "Variable" || def.parent.kind !== "var") {
- return false;
- }
- }
- return reference.isWrite();
-}
-
-/**
- * Checks whether or not a given loop condition info does not have the modified
- * flag.
- * @param {LoopConditionInfo} condition A loop condition info to check.
- * @returns {boolean} `true` if the loop condition info is "unmodified".
- */
-function isUnmodified(condition) {
- return !condition.modified;
-}
-
-/**
- * Checks whether or not a given loop condition info does not have the modified
- * flag and does not have the group this condition belongs to.
- * @param {LoopConditionInfo} condition A loop condition info to check.
- * @returns {boolean} `true` if the loop condition info is "unmodified".
- */
-function isUnmodifiedAndNotBelongToGroup(condition) {
- return !(condition.modified || condition.group);
-}
-
-/**
- * Checks whether or not a given reference is inside of a given node.
- * @param {ASTNode} node A node to check.
- * @param {eslint-scope.Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is inside of the node.
- */
-function isInRange(node, reference) {
- const or = node.range;
- const ir = reference.identifier.range;
-
- return or[0] <= ir[0] && ir[1] <= or[1];
-}
-
-/**
- * Checks whether or not a given reference is inside of a loop node's condition.
- * @param {ASTNode} node A node to check.
- * @param {eslint-scope.Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is inside of the loop node's
- * condition.
- */
-const isInLoop = {
- WhileStatement: isInRange,
- DoWhileStatement: isInRange,
- ForStatement(node, reference) {
- return (
- isInRange(node, reference) &&
- !(node.init && isInRange(node.init, reference))
- );
- }
-};
-
-/**
- * Gets the function which encloses a given reference.
- * This supports only FunctionDeclaration.
- * @param {eslint-scope.Reference} reference A reference to get.
- * @returns {ASTNode|null} The function node or null.
- */
-function getEncloseFunctionDeclaration(reference) {
- let node = reference.identifier;
-
- while (node) {
- if (node.type === "FunctionDeclaration") {
- return node.id ? node : null;
- }
-
- node = node.parent;
- }
-
- return null;
-}
-
-/**
- * Updates the "modified" flags of given loop conditions with given modifiers.
- * @param {LoopConditionInfo[]} conditions The loop conditions to be updated.
- * @param {eslint-scope.Reference[]} modifiers The references to update.
- * @returns {void}
- */
-function updateModifiedFlag(conditions, modifiers) {
-
- for (let i = 0; i < conditions.length; ++i) {
- const condition = conditions[i];
-
- for (let j = 0; !condition.modified && j < modifiers.length; ++j) {
- const modifier = modifiers[j];
- let funcNode, funcVar;
-
- /*
- * Besides checking for the condition being in the loop, we want to
- * check the function that this modifier is belonging to is called
- * in the loop.
- * FIXME: This should probably be extracted to a function.
- */
- const inLoop = condition.isInLoop(modifier) || Boolean(
- (funcNode = getEncloseFunctionDeclaration(modifier)) &&
- (funcVar = astUtils.getVariableByName(modifier.from.upper, funcNode.id.name)) &&
- funcVar.references.some(condition.isInLoop)
- );
-
- condition.modified = inLoop;
- }
- }
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
- meta: {
- type: "problem",
-
- docs: {
- description: "disallow unmodified loop conditions",
- category: "Best Practices",
- recommended: false,
- url: "https://eslint.org/docs/rules/no-unmodified-loop-condition"
- },
-
- schema: []
- },
-
- create(context) {
- const sourceCode = context.getSourceCode();
- let groupMap = null;
-
- /**
- * Reports a given condition info.
- * @param {LoopConditionInfo} condition A loop condition info to report.
- * @returns {void}
- */
- function report(condition) {
- const node = condition.reference.identifier;
-
- context.report({
- node,
- message: "'{{name}}' is not modified in this loop.",
- data: node
- });
- }
-
- /**
- * Registers given conditions to the group the condition belongs to.
- * @param {LoopConditionInfo[]} conditions A loop condition info to
- * register.
- * @returns {void}
- */
- function registerConditionsToGroup(conditions) {
- for (let i = 0; i < conditions.length; ++i) {
- const condition = conditions[i];
-
- if (condition.group) {
- let group = groupMap.get(condition.group);
-
- if (!group) {
- group = [];
- groupMap.set(condition.group, group);
- }
- group.push(condition);
- }
- }
- }
-
- /**
- * Reports references which are inside of unmodified groups.
- * @param {LoopConditionInfo[]} conditions A loop condition info to report.
- * @returns {void}
- */
- function checkConditionsInGroup(conditions) {
- if (conditions.every(isUnmodified)) {
- conditions.forEach(report);
- }
- }
-
- /**
- * Checks whether or not a given group node has any dynamic elements.
- * @param {ASTNode} root A node to check.
- * This node is one of BinaryExpression or ConditionalExpression.
- * @returns {boolean} `true` if the node is dynamic.
- */
- function hasDynamicExpressions(root) {
- let retv = false;
-
- Traverser.traverse(root, {
- visitorKeys: sourceCode.visitorKeys,
- enter(node) {
- if (DYNAMIC_PATTERN.test(node.type)) {
- retv = true;
- this.break();
- } else if (SKIP_PATTERN.test(node.type)) {
- this.skip();
- }
- }
- });
-
- return retv;
- }
-
- /**
- * Creates the loop condition information from a given reference.
- * @param {eslint-scope.Reference} reference A reference to create.
- * @returns {LoopConditionInfo|null} Created loop condition info, or null.
- */
- function toLoopCondition(reference) {
- if (reference.init) {
- return null;
- }
-
- let group = null;
- let child = reference.identifier;
- let node = child.parent;
-
- while (node) {
- if (SENTINEL_PATTERN.test(node.type)) {
- if (LOOP_PATTERN.test(node.type) && node.test === child) {
-
- // This reference is inside of a loop condition.
- return {
- reference,
- group,
- isInLoop: isInLoop[node.type].bind(null, node),
- modified: false
- };
- }
-
- // This reference is outside of a loop condition.
- break;
- }
-
- /*
- * If it's inside of a group, OK if either operand is modified.
- * So stores the group this reference belongs to.
- */
- if (GROUP_PATTERN.test(node.type)) {
-
- // If this expression is dynamic, no need to check.
- if (hasDynamicExpressions(node)) {
- break;
- } else {
- group = node;
- }
- }
-
- child = node;
- node = node.parent;
- }
-
- return null;
- }
-
- /**
- * Finds unmodified references which are inside of a loop condition.
- * Then reports the references which are outside of groups.
- * @param {eslint-scope.Variable} variable A variable to report.
- * @returns {void}
- */
- function checkReferences(variable) {
-
- // Gets references that exist in loop conditions.
- const conditions = variable
- .references
- .map(toLoopCondition)
- .filter(Boolean);
-
- if (conditions.length === 0) {
- return;
- }
-
- // Registers the conditions to belonging groups.
- registerConditionsToGroup(conditions);
-
- // Check the conditions are modified.
- const modifiers = variable.references.filter(isWriteReference);
-
- if (modifiers.length > 0) {
- updateModifiedFlag(conditions, modifiers);
- }
-
- /*
- * Reports the conditions which are not belonging to groups.
- * Others will be reported after all variables are done.
- */
- conditions
- .filter(isUnmodifiedAndNotBelongToGroup)
- .forEach(report);
- }
-
- return {
- "Program:exit"() {
- const queue = [context.getScope()];
-
- groupMap = new Map();
-
- let scope;
-
- while ((scope = queue.pop())) {
- queue.push(...scope.childScopes);
- scope.variables.forEach(checkReferences);
- }
-
- groupMap.forEach(checkConditionsInGroup);
- groupMap = null;
- }
- };
- }
-};
projects / dotfiles / .git / blobdiff