@alexlit/lint-kit 126.7.0 → 127.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-constant-binary-expression.js

@@ -1,508 +0,0 @@
-/**
- * @fileoverview Rule to flag constant comparisons and logical expressions that always/never short circuit
- * @author Jordan Eldredge <https://jordaneldredge.com>
- */
-
-"use strict";
-
-const { isNullLiteral, isConstant, isReferenceToGlobalVariable, isLogicalAssignmentOperator, ECMASCRIPT_GLOBALS } = require("./utils/ast-utils");
-
-const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set(["+", "-", "*", "/", "%", "|", "^", "&", "**", "<<", ">>", ">>>"]);
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not a node is `null` or `undefined`. Similar to the one
- * found in ast-utils.js, but this one correctly handles the edge case that
- * `undefined` has been redefined.
- * @param {Scope} scope Scope in which the expression was found.
- * @param {ASTNode} node A node to check.
- * @returns {boolean} Whether or not the node is a `null` or `undefined`.
- * @public
- */
-function isNullOrUndefined(scope, node) {
-    return (
-        isNullLiteral(node) ||
-        (node.type === "Identifier" && node.name === "undefined" && isReferenceToGlobalVariable(scope, node)) ||
-        (node.type === "UnaryExpression" && node.operator === "void")
-    );
-}
-
-/**
- * Test if an AST node has a statically knowable constant nullishness. Meaning,
- * it will always resolve to a constant value of either: `null`, `undefined`
- * or not `null` _or_ `undefined`. An expression that can vary between those
- * three states at runtime would return `false`.
- * @param {Scope} scope The scope in which the node was found.
- * @param {ASTNode} node The AST node being tested.
- * @param {boolean} nonNullish if `true` then nullish values are not considered constant.
- * @returns {boolean} Does `node` have constant nullishness?
- */
-function hasConstantNullishness(scope, node, nonNullish) {
-    if (nonNullish && isNullOrUndefined(scope, node)) {
-        return false;
-    }
-
-    switch (node.type) {
-        case "ObjectExpression": // Objects are never nullish
-        case "ArrayExpression": // Arrays are never nullish
-        case "ArrowFunctionExpression": // Functions never nullish
-        case "FunctionExpression": // Functions are never nullish
-        case "ClassExpression": // Classes are never nullish
-        case "NewExpression": // Objects are never nullish
-        case "Literal": // Nullish, or non-nullish, literals never change
-        case "TemplateLiteral": // A string is never nullish
-        case "UpdateExpression": // Numbers are never nullish
-        case "BinaryExpression": // Numbers, strings, or booleans are never nullish
-            return true;
-        case "CallExpression": {
-            if (node.callee.type !== "Identifier") {
-                return false;
-            }
-            const functionName = node.callee.name;
-
-            return (functionName === "Boolean" || functionName === "String" || functionName === "Number") &&
-                isReferenceToGlobalVariable(scope, node.callee);
-        }
-        case "LogicalExpression": {
-            return node.operator === "??" && hasConstantNullishness(scope, node.right, true);
-        }
-        case "AssignmentExpression":
-            if (node.operator === "=") {
-                return hasConstantNullishness(scope, node.right, nonNullish);
-            }
-
-            /*
-             * Handling short-circuiting assignment operators would require
-             * walking the scope. We won't attempt that (for now...) /
-             */
-            if (isLogicalAssignmentOperator(node.operator)) {
-                return false;
-            }
-
-            /*
-             * The remaining assignment expressions all result in a numeric or
-             * string (non-nullish) value:
-             *   "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&="
-             */
-
-            return true;
-        case "UnaryExpression":
-
-            /*
-             * "void" Always returns `undefined`
-             * "typeof" All types are strings, and thus non-nullish
-             * "!" Boolean is never nullish
-             * "delete" Returns a boolean, which is never nullish
-             * Math operators always return numbers or strings, neither of which
-             * are non-nullish "+", "-", "~"
-             */
-
-            return true;
-        case "SequenceExpression": {
-            const last = node.expressions.at(-1);
-
-            return hasConstantNullishness(scope, last, nonNullish);
-        }
-        case "Identifier":
-            return node.name === "undefined" && isReferenceToGlobalVariable(scope, node);
-        case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior.
-        case "JSXFragment":
-            return false;
-        default:
-            return false;
-    }
-}
-
-/**
- * Test if an AST node is a boolean value that never changes. Specifically we
- * test for:
- * 1. Literal booleans (`true` or `false`)
- * 2. Unary `!` expressions with a constant value
- * 3. Constant booleans created via the `Boolean` global function
- * @param {Scope} scope The scope in which the node was found.
- * @param {ASTNode} node The node to test
- * @returns {boolean} Is `node` guaranteed to be a boolean?
- */
-function isStaticBoolean(scope, node) {
-    switch (node.type) {
-        case "Literal":
-            return typeof node.value === "boolean";
-        case "CallExpression":
-            return node.callee.type === "Identifier" && node.callee.name === "Boolean" &&
-              isReferenceToGlobalVariable(scope, node.callee) &&
-              (node.arguments.length === 0 || isConstant(scope, node.arguments[0], true));
-        case "UnaryExpression":
-            return node.operator === "!" && isConstant(scope, node.argument, true);
-        default:
-            return false;
-    }
-}
-
-
-/**
- * Test if an AST node will always give the same result when compared to a
- * boolean value. Note that comparison to boolean values is different than
- * truthiness.
- * https://262.ecma-international.org/5.1/#sec-11.9.3
- *
- * JavaScript `==` operator works by converting the boolean to `1` (true) or
- * `+0` (false) and then checks the values `==` equality to that number.
- * @param {Scope} scope The scope in which node was found.
- * @param {ASTNode} node The node to test.
- * @returns {boolean} Will `node` always coerce to the same boolean value?
- */
-function hasConstantLooseBooleanComparison(scope, node) {
-    switch (node.type) {
-        case "ObjectExpression":
-        case "ClassExpression":
-
-            /**
-             * In theory objects like:
-             *
-             * `{toString: () => a}`
-             * `{valueOf: () => a}`
-             *
-             * Or a classes like:
-             *
-             * `class { static toString() { return a } }`
-             * `class { static valueOf() { return a } }`
-             *
-             * Are not constant verifiably when `inBooleanPosition` is
-             * false, but it's an edge case we've opted not to handle.
-             */
-            return true;
-        case "ArrayExpression": {
-            const nonSpreadElements = node.elements.filter(e =>
-
-                // Elements can be `null` in sparse arrays: `[,,]`;
-                e !== null && e.type !== "SpreadElement");
-
-
-            /*
-             * Possible future direction if needed: We could check if the
-             * single value would result in variable boolean comparison.
-             * For now we will err on the side of caution since `[x]` could
-             * evaluate to `[0]` or `[1]`.
-             */
-            return node.elements.length === 0 || nonSpreadElements.length > 1;
-        }
-        case "ArrowFunctionExpression":
-        case "FunctionExpression":
-            return true;
-        case "UnaryExpression":
-            if (node.operator === "void" || // Always returns `undefined`
-                node.operator === "typeof" // All `typeof` strings, when coerced to number, are not 0 or 1.
-            ) {
-                return true;
-            }
-            if (node.operator === "!") {
-                return isConstant(scope, node.argument, true);
-            }
-
-            /*
-             * We won't try to reason about +, -, ~, or delete
-             * In theory, for the mathematical operators, we could look at the
-             * argument and try to determine if it coerces to a constant numeric
-             * value.
-             */
-            return false;
-        case "NewExpression": // Objects might have custom `.valueOf` or `.toString`.
-            return false;
-        case "CallExpression": {
-            if (node.callee.type === "Identifier" &&
-                node.callee.name === "Boolean" &&
-                isReferenceToGlobalVariable(scope, node.callee)
-            ) {
-                return node.arguments.length === 0 || isConstant(scope, node.arguments[0], true);
-            }
-            return false;
-        }
-        case "Literal": // True or false, literals never change
-            return true;
-        case "Identifier":
-            return node.name === "undefined" && isReferenceToGlobalVariable(scope, node);
-        case "TemplateLiteral":
-
-            /*
-             * In theory we could try to check if the quasi are sufficient to
-             * prove that the expression will always be true, but it would be
-             * tricky to get right. For example: `000.${foo}000`
-             */
-            return node.expressions.length === 0;
-        case "AssignmentExpression":
-            if (node.operator === "=") {
-                return hasConstantLooseBooleanComparison(scope, node.right);
-            }
-
-            /*
-             * Handling short-circuiting assignment operators would require
-             * walking the scope. We won't attempt that (for now...)
-             *
-             * The remaining assignment expressions all result in a numeric or
-             * string (non-nullish) values which could be truthy or falsy:
-             *   "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&="
-             */
-            return false;
-        case "SequenceExpression": {
-            const last = node.expressions.at(-1);
-
-            return hasConstantLooseBooleanComparison(scope, last);
-        }
-        case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior.
-        case "JSXFragment":
-            return false;
-        default:
-            return false;
-    }
-}
-
-
-/**
- * Test if an AST node will always give the same result when _strictly_ compared
- * to a boolean value. This can happen if the expression can never be boolean, or
- * if it is always the same boolean value.
- * @param {Scope} scope The scope in which the node was found.
- * @param {ASTNode} node The node to test
- * @returns {boolean} Will `node` always give the same result when compared to a
- * static boolean value?
- */
-function hasConstantStrictBooleanComparison(scope, node) {
-    switch (node.type) {
-        case "ObjectExpression": // Objects are not booleans
-        case "ArrayExpression": // Arrays are not booleans
-        case "ArrowFunctionExpression": // Functions are not booleans
-        case "FunctionExpression":
-        case "ClassExpression": // Classes are not booleans
-        case "NewExpression": // Objects are not booleans
-        case "TemplateLiteral": // Strings are not booleans
-        case "Literal": // True, false, or not boolean, literals never change.
-        case "UpdateExpression": // Numbers are not booleans
-            return true;
-        case "BinaryExpression":
-            return NUMERIC_OR_STRING_BINARY_OPERATORS.has(node.operator);
-        case "UnaryExpression": {
-            if (node.operator === "delete") {
-                return false;
-            }
-            if (node.operator === "!") {
-                return isConstant(scope, node.argument, true);
-            }
-
-            /*
-             * The remaining operators return either strings or numbers, neither
-             * of which are boolean.
-             */
-            return true;
-        }
-        case "SequenceExpression": {
-            const last = node.expressions.at(-1);
-
-            return hasConstantStrictBooleanComparison(scope, last);
-        }
-        case "Identifier":
-            return node.name === "undefined" && isReferenceToGlobalVariable(scope, node);
-        case "AssignmentExpression":
-            if (node.operator === "=") {
-                return hasConstantStrictBooleanComparison(scope, node.right);
-            }
-
-            /*
-             * Handling short-circuiting assignment operators would require
-             * walking the scope. We won't attempt that (for now...)
-             */
-            if (isLogicalAssignmentOperator(node.operator)) {
-                return false;
-            }
-
-            /*
-             * The remaining assignment expressions all result in either a number
-             * or a string, neither of which can ever be boolean.
-             */
-            return true;
-        case "CallExpression": {
-            if (node.callee.type !== "Identifier") {
-                return false;
-            }
-            const functionName = node.callee.name;
-
-            if (
-                (functionName === "String" || functionName === "Number") &&
-                isReferenceToGlobalVariable(scope, node.callee)
-            ) {
-                return true;
-            }
-            if (functionName === "Boolean" && isReferenceToGlobalVariable(scope, node.callee)) {
-                return (
-                    node.arguments.length === 0 || isConstant(scope, node.arguments[0], true));
-            }
-            return false;
-        }
-        case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior.
-        case "JSXFragment":
-            return false;
-        default:
-            return false;
-    }
-}
-
-/**
- * Test if an AST node will always result in a newly constructed object
- * @param {Scope} scope The scope in which the node was found.
- * @param {ASTNode} node The node to test
- * @returns {boolean} Will `node` always be new?
- */
-function isAlwaysNew(scope, node) {
-    switch (node.type) {
-        case "ObjectExpression":
-        case "ArrayExpression":
-        case "ArrowFunctionExpression":
-        case "FunctionExpression":
-        case "ClassExpression":
-            return true;
-        case "NewExpression": {
-            if (node.callee.type !== "Identifier") {
-                return false;
-            }
-
-            /*
-             * All the built-in constructors are always new, but
-             * user-defined constructors could return a sentinel
-             * object.
-             *
-             * Catching these is especially useful for primitive constructors
-             * which return boxed values, a surprising gotcha' in JavaScript.
-             */
-            return Object.hasOwn(ECMASCRIPT_GLOBALS, node.callee.name) &&
-              isReferenceToGlobalVariable(scope, node.callee);
-        }
-        case "Literal":
-
-            // Regular expressions are objects, and thus always new
-            return typeof node.regex === "object";
-        case "SequenceExpression": {
-            const last = node.expressions.at(-1);
-
-            return isAlwaysNew(scope, last);
-        }
-        case "AssignmentExpression":
-            if (node.operator === "=") {
-                return isAlwaysNew(scope, node.right);
-            }
-            return false;
-        case "ConditionalExpression":
-            return isAlwaysNew(scope, node.consequent) && isAlwaysNew(scope, node.alternate);
-        case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior.
-        case "JSXFragment":
-            return false;
-        default:
-            return false;
-    }
-}
-
-/**
- * Checks if one operand will cause the result to be constant.
- * @param {Scope} scope Scope in which the expression was found.
- * @param {ASTNode} a One side of the expression
- * @param {ASTNode} b The other side of the expression
- * @param {string} operator The binary expression operator
- * @returns {ASTNode | null} The node which will cause the expression to have a constant result.
- */
-function findBinaryExpressionConstantOperand(scope, a, b, operator) {
-    if (operator === "==" || operator === "!=") {
-        if (
-            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b, false)) ||
-            (isStaticBoolean(scope, a) && hasConstantLooseBooleanComparison(scope, b))
-        ) {
-            return b;
-        }
-    } else if (operator === "===" || operator === "!==") {
-        if (
-            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b, false)) ||
-            (isStaticBoolean(scope, a) && hasConstantStrictBooleanComparison(scope, b))
-        ) {
-            return b;
-        }
-    }
-    return null;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-        docs: {
-            description: "Disallow expressions where the operation doesn't affect the value",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-constant-binary-expression"
-        },
-        schema: [],
-        messages: {
-            constantBinaryOperand: "Unexpected constant binary expression. Compares constantly with the {{otherSide}}-hand side of the `{{operator}}`.",
-            constantShortCircuit: "Unexpected constant {{property}} on the left-hand side of a `{{operator}}` expression.",
-            alwaysNew: "Unexpected comparison to newly constructed object. These two values can never be equal.",
-            bothAlwaysNew: "Unexpected comparison of two newly constructed objects. These two values can never be equal."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            LogicalExpression(node) {
-                const { operator, left } = node;
-                const scope = sourceCode.getScope(node);
-
-                if ((operator === "&&" || operator === "||") && isConstant(scope, left, true)) {
-                    context.report({ node: left, messageId: "constantShortCircuit", data: { property: "truthiness", operator } });
-                } else if (operator === "??" && hasConstantNullishness(scope, left, false)) {
-                    context.report({ node: left, messageId: "constantShortCircuit", data: { property: "nullishness", operator } });
-                }
-            },
-            BinaryExpression(node) {
-                const scope = sourceCode.getScope(node);
-                const { right, left, operator } = node;
-                const rightConstantOperand = findBinaryExpressionConstantOperand(scope, left, right, operator);
-                const leftConstantOperand = findBinaryExpressionConstantOperand(scope, right, left, operator);
-
-                if (rightConstantOperand) {
-                    context.report({ node: rightConstantOperand, messageId: "constantBinaryOperand", data: { operator, otherSide: "left" } });
-                } else if (leftConstantOperand) {
-                    context.report({ node: leftConstantOperand, messageId: "constantBinaryOperand", data: { operator, otherSide: "right" } });
-                } else if (operator === "===" || operator === "!==") {
-                    if (isAlwaysNew(scope, left)) {
-                        context.report({ node: left, messageId: "alwaysNew" });
-                    } else if (isAlwaysNew(scope, right)) {
-                        context.report({ node: right, messageId: "alwaysNew" });
-                    }
-                } else if (operator === "==" || operator === "!=") {
-
-                    /*
-                     * If both sides are "new", then both sides are objects and
-                     * therefore they will be compared by reference even with `==`
-                     * equality.
-                     */
-                    if (isAlwaysNew(scope, left) && isAlwaysNew(scope, right)) {
-                        context.report({ node: left, messageId: "bothAlwaysNew" });
-                    }
-                }
-
-            }
-
-            /*
-             * In theory we could handle short-circuiting assignment operators,
-             * for some constant values, but that would require walking the
-             * scope to find the value of the variable being assigned. This is
-             * dependant on https://github.com/eslint/eslint/issues/13776
-             *
-             * AssignmentExpression() {},
-             */
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-constant-condition.js

@@ -1,161 +0,0 @@
-/**
- * @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('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        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 options = context.options[0] || {};
-        let checkLoops = options.checkLoops ?? "allExceptWhileTrue";
-        const loopSetStack = [];
-        const sourceCode = context.sourceCode;
-
-        if (options.checkLoops === true) {
-            checkLoops = "all";
-        } else if (options.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()
-        };
-
-    }
-};