node_modules/eslint/lib/rules/no-constant-condition.js

/**
 * @fileoverview Rule to flag use constant conditions
 * @author Christian Schulz <http://rndm.de>
 */

"use strict";

const { isConstant } = require("./utils/ast-utils");

//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
	meta: {
		type: "problem",

		defaultOptions: [{ checkLoops: "allExceptWhileTrue" }],

		docs: {
			description: "Disallow constant expressions in conditions",
			recommended: true,
			url: "https://eslint.org/docs/latest/rules/no-constant-condition",
		},

		schema: [
			{
				type: "object",
				properties: {
					checkLoops: {
						enum: [
							"all",
							"allExceptWhileTrue",
							"none",
							true,
							false,
						],
					},
				},
				additionalProperties: false,
			},
		],

		messages: {
			unexpected: "Unexpected constant condition.",
		},
	},

	create(context) {
		const loopSetStack = [];
		const sourceCode = context.sourceCode;
		let [{ checkLoops }] = context.options;

		if (checkLoops === true) {
			checkLoops = "all";
		} else if (checkLoops === false) {
			checkLoops = "none";
		}

		let loopsInCurrentScope = new Set();

		//--------------------------------------------------------------------------
		// Helpers
		//--------------------------------------------------------------------------

		/**
		 * Tracks when the given node contains a constant condition.
		 * @param {ASTNode} node The AST node to check.
		 * @returns {void}
		 * @private
		 */
		function trackConstantConditionLoop(node) {
			if (
				node.test &&
				isConstant(sourceCode.getScope(node), node.test, true)
			) {
				loopsInCurrentScope.add(node);
			}
		}

		/**
		 * Reports when the set contains the given constant condition node
		 * @param {ASTNode} node The AST node to check.
		 * @returns {void}
		 * @private
		 */
		function checkConstantConditionLoopInSet(node) {
			if (loopsInCurrentScope.has(node)) {
				loopsInCurrentScope.delete(node);
				context.report({ node: node.test, messageId: "unexpected" });
			}
		}

		/**
		 * Reports when the given node contains a constant condition.
		 * @param {ASTNode} node The AST node to check.
		 * @returns {void}
		 * @private
		 */
		function reportIfConstant(node) {
			if (
				node.test &&
				isConstant(sourceCode.getScope(node), node.test, true)
			) {
				context.report({ node: node.test, messageId: "unexpected" });
			}
		}

		/**
		 * Stores current set of constant loops in loopSetStack temporarily
		 * and uses a new set to track constant loops
		 * @returns {void}
		 * @private
		 */
		function enterFunction() {
			loopSetStack.push(loopsInCurrentScope);
			loopsInCurrentScope = new Set();
		}

		/**
		 * Reports when the set still contains stored constant conditions
		 * @returns {void}
		 * @private
		 */
		function exitFunction() {
			loopsInCurrentScope = loopSetStack.pop();
		}

		/**
		 * Checks node when checkLoops option is enabled
		 * @param {ASTNode} node The AST node to check.
		 * @returns {void}
		 * @private
		 */
		function checkLoop(node) {
			if (checkLoops === "all" || checkLoops === "allExceptWhileTrue") {
				trackConstantConditionLoop(node);
			}
		}

		//--------------------------------------------------------------------------
		// Public
		//--------------------------------------------------------------------------

		return {
			ConditionalExpression: reportIfConstant,
			IfStatement: reportIfConstant,
			WhileStatement(node) {
				if (
					node.test.type === "Literal" &&
					node.test.value === true &&
					checkLoops === "allExceptWhileTrue"
				) {
					return;
				}

				checkLoop(node);
			},
			"WhileStatement:exit": checkConstantConditionLoopInSet,
			DoWhileStatement: checkLoop,
			"DoWhileStatement:exit": checkConstantConditionLoopInSet,
			ForStatement: checkLoop,
			"ForStatement > .test": node => checkLoop(node.parent),
			"ForStatement:exit": checkConstantConditionLoopInSet,
			FunctionDeclaration: enterFunction,
			"FunctionDeclaration:exit": exitFunction,
			FunctionExpression: enterFunction,
			"FunctionExpression:exit": exitFunction,
			YieldExpression: () => loopsInCurrentScope.clear(),
		};
	},
};