eslint 8.57.0 → 9.2.0

package/lib/rules/one-var.js

@@ -109,12 +109,12 @@ module.exports = {
             options.var = { uninitialized: mode.var, initialized: mode.var };
             options.let = { uninitialized: mode.let, initialized: mode.let };
             options.const = { uninitialized: mode.const, initialized: mode.const };
-            if (Object.prototype.hasOwnProperty.call(mode, "uninitialized")) {
+            if (Object.hasOwn(mode, "uninitialized")) {
                 options.var.uninitialized = mode.uninitialized;
                 options.let.uninitialized = mode.uninitialized;
                 options.const.uninitialized = mode.uninitialized;
             }
-            if (Object.prototype.hasOwnProperty.call(mode, "initialized")) {
+            if (Object.hasOwn(mode, "initialized")) {
                 options.var.initialized = mode.initialized;
                 options.let.initialized = mode.initialized;
                 options.const.initialized = mode.initialized;
@@ -216,11 +216,11 @@ module.exports = {
             let currentScope;
 
             if (statementType === "var") {
-                currentScope = functionStack[functionStack.length - 1];
+                currentScope = functionStack.at(-1);
             } else if (statementType === "let") {
-                currentScope = blockStack[blockStack.length - 1].let;
+                currentScope = blockStack.at(-1).let;
             } else if (statementType === "const") {
-                currentScope = blockStack[blockStack.length - 1].const;
+                currentScope = blockStack.at(-1).const;
             }
             return currentScope;
         }

package/lib/rules/padded-blocks.js

@@ -84,18 +84,18 @@ module.exports = {
             options.switches = shouldHavePadding;
             options.classes = shouldHavePadding;
         } else {
-            if (Object.prototype.hasOwnProperty.call(typeOptions, "blocks")) {
+            if (Object.hasOwn(typeOptions, "blocks")) {
                 options.blocks = typeOptions.blocks === "always";
             }
-            if (Object.prototype.hasOwnProperty.call(typeOptions, "switches")) {
+            if (Object.hasOwn(typeOptions, "switches")) {
                 options.switches = typeOptions.switches === "always";
             }
-            if (Object.prototype.hasOwnProperty.call(typeOptions, "classes")) {
+            if (Object.hasOwn(typeOptions, "classes")) {
                 options.classes = typeOptions.classes === "always";
             }
         }
 
-        if (Object.prototype.hasOwnProperty.call(exceptOptions, "allowSingleLineBlocks")) {
+        if (Object.hasOwn(exceptOptions, "allowSingleLineBlocks")) {
             options.allowSingleLineBlocks = exceptOptions.allowSingleLineBlocks === true;
         }
 
@@ -277,7 +277,7 @@ module.exports = {
 
         const rule = {};
 
-        if (Object.prototype.hasOwnProperty.call(options, "switches")) {
+        if (Object.hasOwn(options, "switches")) {
             rule.SwitchStatement = function(node) {
                 if (node.cases.length === 0) {
                     return;
@@ -286,7 +286,7 @@ module.exports = {
             };
         }
 
-        if (Object.prototype.hasOwnProperty.call(options, "blocks")) {
+        if (Object.hasOwn(options, "blocks")) {
             rule.BlockStatement = function(node) {
                 if (node.body.length === 0) {
                     return;
@@ -296,7 +296,7 @@ module.exports = {
             rule.StaticBlock = rule.BlockStatement;
         }
 
-        if (Object.prototype.hasOwnProperty.call(options, "classes")) {
+        if (Object.hasOwn(options, "classes")) {
             rule.ClassBody = function(node) {
                 if (node.body.length === 0) {
                     return;

package/lib/rules/prefer-arrow-callback.js

@@ -220,7 +220,7 @@ module.exports = {
 
             // If there are below, it cannot replace with arrow functions merely.
             ThisExpression() {
-                const info = stack[stack.length - 1];
+                const info = stack.at(-1);
 
                 if (info) {
                     info.this = true;
@@ -228,7 +228,7 @@ module.exports = {
             },
 
             Super() {
-                const info = stack[stack.length - 1];
+                const info = stack.at(-1);
 
                 if (info) {
                     info.super = true;
@@ -236,7 +236,7 @@ module.exports = {
             },
 
             MetaProperty(node) {
-                const info = stack[stack.length - 1];
+                const info = stack.at(-1);
 
                 if (info && checkMetaProperty(node, "new", "target")) {
                     info.meta = true;

package/lib/rules/prefer-reflect.js

@@ -105,7 +105,7 @@ module.exports = {
             CallExpression(node) {
                 const methodName = (node.callee.property || {}).name;
                 const isReflectCall = (node.callee.object || {}).name === "Reflect";
-                const hasReflectSubstitute = Object.prototype.hasOwnProperty.call(reflectSubstitutes, methodName);
+                const hasReflectSubstitute = Object.hasOwn(reflectSubstitutes, methodName);
                 const userConfiguredException = exceptions.includes(methodName);
 
                 if (hasReflectSubstitute && !isReflectCall && !userConfiguredException) {

package/lib/rules/prefer-regex-literals.js

@@ -34,7 +34,7 @@ function isStringLiteral(node) {
  * @returns {boolean} True if the node is a regex literal.
  */
 function isRegexLiteral(node) {
-    return node.type === "Literal" && Object.prototype.hasOwnProperty.call(node, "regex");
+    return node.type === "Literal" && Object.hasOwn(node, "regex");
 }
 
 const validPrecedingTokens = new Set([

package/lib/rules/prefer-template.js

@@ -113,7 +113,7 @@ function endsWithTemplateCurly(node) {
         return startsWithTemplateCurly(node.right);
     }
     if (node.type === "TemplateLiteral") {
-        return node.expressions.length && node.quasis.length && node.quasis[node.quasis.length - 1].range[0] === node.quasis[node.quasis.length - 1].range[1];
+        return node.expressions.length && node.quasis.length && node.quasis.at(-1).range[0] === node.quasis.at(-1).range[1];
     }
     return node.type !== "Literal" || typeof node.value !== "string";
 }

package/lib/rules/radix.js

@@ -133,8 +133,8 @@ module.exports = {
                                     messageId: "addRadixParameter10",
                                     fix(fixer) {
                                         const tokens = sourceCode.getTokens(node);
-                                        const lastToken = tokens[tokens.length - 1]; // Parenthesis.
-                                        const secondToLastToken = tokens[tokens.length - 2]; // May or may not be a comma.
+                                        const lastToken = tokens.at(-1); // Parenthesis.
+                                        const secondToLastToken = tokens.at(-2); // May or may not be a comma.
                                         const hasTrailingComma = secondToLastToken.type === "Punctuator" && secondToLastToken.value === ",";
 
                                         return fixer.insertTextBefore(lastToken, hasTrailingComma ? " 10," : ", 10");

package/lib/rules/semi-style.js

@@ -65,7 +65,7 @@ function isLastChild(node) {
     }
     const nodeList = getChildren(node.parent);
 
-    return nodeList !== null && nodeList[nodeList.length - 1] === node; // before `}` or etc.
+    return nodeList !== null && nodeList.at(-1) === node; // before `}` or etc.
 }
 
 /** @type {import('../shared/types').Rule} */

package/lib/rules/sort-imports.js

@@ -208,7 +208,7 @@ module.exports = {
                                 }
 
                                 return fixer.replaceTextRange(
-                                    [importSpecifiers[0].range[0], importSpecifiers[importSpecifiers.length - 1].range[1]],
+                                    [importSpecifiers[0].range[0], importSpecifiers.at(-1).range[1]],
                                     importSpecifiers
 
                                         // Clone the importSpecifiers array to avoid mutating it

package/lib/rules/sort-keys.js

@@ -185,7 +185,7 @@ module.exports = {
                     });
 
                     // check blank line between the current node and the last token
-                    if (!isBlankLineBetweenNodes && (node.loc.start.line - tokens[tokens.length - 1].loc.end.line > 1)) {
+                    if (!isBlankLineBetweenNodes && (node.loc.start.line - tokens.at(-1).loc.end.line > 1)) {
                         isBlankLineBetweenNodes = true;
                     }
 

package/lib/rules/sort-vars.js

@@ -66,7 +66,7 @@ module.exports = {
                                     return null;
                                 }
                                 return fixer.replaceTextRange(
-                                    [idDeclarations[0].range[0], idDeclarations[idDeclarations.length - 1].range[1]],
+                                    [idDeclarations[0].range[0], idDeclarations.at(-1).range[1]],
                                     idDeclarations
 
                                         // Clone the idDeclarations array to avoid mutating it

package/lib/rules/space-unary-ops.js

@@ -87,7 +87,7 @@ module.exports = {
          * @returns {boolean} Whether or not an override has been provided for the operator
          */
         function overrideExistsForOperator(operator) {
-            return options.overrides && Object.prototype.hasOwnProperty.call(options.overrides, operator);
+            return options.overrides && Object.hasOwn(options.overrides, operator);
         }
 
         /**

package/lib/rules/strict.js

@@ -173,7 +173,7 @@ module.exports = {
         function enterFunctionInFunctionMode(node, useStrictDirectives) {
             const isInClass = classScopes.length > 0,
                 isParentGlobal = scopes.length === 0 && classScopes.length === 0,
-                isParentStrict = scopes.length > 0 && scopes[scopes.length - 1],
+                isParentStrict = scopes.length > 0 && scopes.at(-1),
                 isStrict = useStrictDirectives.length > 0;
 
             if (isStrict) {

package/lib/rules/use-isnan.js

@@ -21,9 +21,17 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} `true` if the node is 'NaN' identifier.
  */
 function isNaNIdentifier(node) {
-    return Boolean(node) && (
-        astUtils.isSpecificId(node, "NaN") ||
-        astUtils.isSpecificMemberAccess(node, "Number", "NaN")
+    if (!node) {
+        return false;
+    }
+
+    const nodeToCheck = node.type === "SequenceExpression"
+        ? node.expressions.at(-1)
+        : node;
+
+    return (
+        astUtils.isSpecificId(nodeToCheck, "NaN") ||
+        astUtils.isSpecificMemberAccess(nodeToCheck, "Number", "NaN")
     );
 }
 
@@ -34,6 +42,7 @@ function isNaNIdentifier(node) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        hasSuggestions: true,
         type: "problem",
 
         docs: {
@@ -63,7 +72,10 @@ module.exports = {
             comparisonWithNaN: "Use the isNaN function to compare with NaN.",
             switchNaN: "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.",
             caseNaN: "'case NaN' can never match. Use Number.isNaN before the switch.",
-            indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN."
+            indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN.",
+            replaceWithIsNaN: "Replace with Number.isNaN.",
+            replaceWithCastingAndIsNaN: "Replace with Number.isNaN and cast to a Number.",
+            replaceWithFindIndex: "Replace with Array.prototype.{{ methodName }}."
         }
     },
 
@@ -71,6 +83,35 @@ module.exports = {
 
         const enforceForSwitchCase = !context.options[0] || context.options[0].enforceForSwitchCase;
         const enforceForIndexOf = context.options[0] && context.options[0].enforceForIndexOf;
+        const sourceCode = context.sourceCode;
+
+        const fixableOperators = new Set(["==", "===", "!=", "!=="]);
+        const castableOperators = new Set(["==", "!="]);
+
+        /**
+         * Get a fixer for a binary expression that compares to NaN.
+         * @param  {ASTNode} node The node to fix.
+         * @param {function(string): string} wrapValue A function that wraps the compared value with a fix.
+         * @returns {function(Fixer): Fix} The fixer function.
+         */
+        function getBinaryExpressionFixer(node, wrapValue) {
+            return fixer => {
+                const comparedValue = isNaNIdentifier(node.left) ? node.right : node.left;
+                const shouldWrap = comparedValue.type === "SequenceExpression";
+                const shouldNegate = node.operator[0] === "!";
+
+                const negation = shouldNegate ? "!" : "";
+                let comparedValueText = sourceCode.getText(comparedValue);
+
+                if (shouldWrap) {
+                    comparedValueText = `(${comparedValueText})`;
+                }
+
+                const fixedValue = wrapValue(comparedValueText);
+
+                return fixer.replaceText(node, `${negation}${fixedValue}`);
+            };
+        }
 
         /**
          * Checks the given `BinaryExpression` node for `foo === NaN` and other comparisons.
@@ -82,7 +123,32 @@ module.exports = {
                 /^(?:[<>]|[!=]=)=?$/u.test(node.operator) &&
                 (isNaNIdentifier(node.left) || isNaNIdentifier(node.right))
             ) {
-                context.report({ node, messageId: "comparisonWithNaN" });
+                const suggestedFixes = [];
+                const NaNNode = isNaNIdentifier(node.left) ? node.left : node.right;
+
+                const isSequenceExpression = NaNNode.type === "SequenceExpression";
+                const isSuggestable = fixableOperators.has(node.operator) && !isSequenceExpression;
+                const isCastable = castableOperators.has(node.operator);
+
+                if (isSuggestable) {
+                    suggestedFixes.push({
+                        messageId: "replaceWithIsNaN",
+                        fix: getBinaryExpressionFixer(node, value => `Number.isNaN(${value})`)
+                    });
+
+                    if (isCastable) {
+                        suggestedFixes.push({
+                            messageId: "replaceWithCastingAndIsNaN",
+                            fix: getBinaryExpressionFixer(node, value => `Number.isNaN(Number(${value}))`)
+                        });
+                    }
+                }
+
+                context.report({
+                    node,
+                    messageId: "comparisonWithNaN",
+                    suggest: suggestedFixes
+                });
             }
         }
 
@@ -116,10 +182,38 @@ module.exports = {
 
                 if (
                     (methodName === "indexOf" || methodName === "lastIndexOf") &&
-                    node.arguments.length === 1 &&
+                    node.arguments.length <= 2 &&
                     isNaNIdentifier(node.arguments[0])
                 ) {
-                    context.report({ node, messageId: "indexOfNaN", data: { methodName } });
+
+                    /*
+                     * To retain side effects, it's essential to address `NaN` beforehand, which
+                     * is not possible with fixes like `arr.findIndex(Number.isNaN)`.
+                     */
+                    const isSuggestable = node.arguments[0].type !== "SequenceExpression" && !node.arguments[1];
+                    const suggestedFixes = [];
+
+                    if (isSuggestable) {
+                        const shouldWrap = callee.computed;
+                        const findIndexMethod = methodName === "indexOf" ? "findIndex" : "findLastIndex";
+                        const propertyName = shouldWrap ? `"${findIndexMethod}"` : findIndexMethod;
+
+                        suggestedFixes.push({
+                            messageId: "replaceWithFindIndex",
+                            data: { methodName: findIndexMethod },
+                            fix: fixer => [
+                                fixer.replaceText(callee.property, propertyName),
+                                fixer.replaceText(node.arguments[0], "Number.isNaN")
+                            ]
+                        });
+                    }
+
+                    context.report({
+                        node,
+                        messageId: "indexOfNaN",
+                        data: { methodName },
+                        suggest: suggestedFixes
+                    });
                 }
             }
         }

package/lib/rules/utils/ast-utils.js

@@ -19,6 +19,8 @@ const {
     lineBreakPattern,
     shebangPattern
 } = require("../../shared/ast-utils");
+const globals = require("../../../conf/globals");
+const { LATEST_ECMA_VERSION } = require("../../../conf/ecma-version");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -46,6 +48,12 @@ const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN = /^(?:[^\\]|\\.)*\\(?:[1-9]|0[0
 
 const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
 
+/**
+ * All builtin global variables defined in the latest ECMAScript specification.
+ * @type {Record<string,boolean>} Key is the name of the variable. Value is `true` if the variable is considered writable, `false` otherwise.
+ */
+const ECMASCRIPT_GLOBALS = globals[`es${LATEST_ECMA_VERSION}`];
+
 /**
  * Checks reference if is non initializer and writable.
  * @param {Reference} reference A reference to check.
@@ -969,7 +977,7 @@ function isConstant(scope, node, inBooleanPosition) {
             return false;
 
         case "SequenceExpression":
-            return isConstant(scope, node.expressions[node.expressions.length - 1], inBooleanPosition);
+            return isConstant(scope, node.expressions.at(-1), inBooleanPosition);
         case "SpreadElement":
             return isConstant(scope, node.argument, inBooleanPosition);
         case "CallExpression":
@@ -1133,6 +1141,7 @@ module.exports = {
     LINEBREAK_MATCHER: lineBreakPattern,
     SHEBANG_MATCHER: shebangPattern,
     STATEMENT_LIST_PARENTS,
+    ECMASCRIPT_GLOBALS,
 
     /**
      * Determines whether two adjacent tokens are on the same line.
@@ -1231,7 +1240,7 @@ module.exports = {
      * @private
      */
     isSurroundedBy(val, character) {
-        return val[0] === character && val[val.length - 1] === character;
+        return val[0] === character && val.at(-1) === character;
     },
 
     /**
@@ -1909,8 +1918,8 @@ module.exports = {
      */
     getFunctionHeadLoc(node, sourceCode) {
         const parent = node.parent;
-        let start = null;
-        let end = null;
+        let start;
+        let end;
 
         if (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") {
             start = parent.loc.start;
@@ -2055,7 +2064,7 @@ module.exports = {
             case "SequenceExpression": {
                 const exprs = node.expressions;
 
-                return exprs.length !== 0 && module.exports.couldBeError(exprs[exprs.length - 1]);
+                return exprs.length !== 0 && module.exports.couldBeError(exprs.at(-1));
             }
 
             case "LogicalExpression":
@@ -2119,9 +2128,9 @@ module.exports = {
 
             const comments = tokens.comments;
 
-            leftToken = tokens[tokens.length - 1];
+            leftToken = tokens.at(-1);
             if (comments.length) {
-                const lastComment = comments[comments.length - 1];
+                const lastComment = comments.at(-1);
 
                 if (!leftToken || lastComment.range[0] > leftToken.range[0]) {
                     leftToken = lastComment;