eslint 8.57.0 → 9.2.0

package/lib/rules/array-bracket-newline.js

@@ -74,7 +74,7 @@ module.exports = {
         function normalizeOptionValue(option) {
             let consistent = false;
             let multiline = false;
-            let minItems = 0;
+            let minItems;
 
             if (option) {
                 if (option === "consistent") {

package/lib/rules/array-bracket-spacing.js

@@ -199,7 +199,7 @@ module.exports = {
                     : sourceCode.getLastToken(node),
                 penultimate = sourceCode.getTokenBefore(last),
                 firstElement = node.elements[0],
-                lastElement = node.elements[node.elements.length - 1];
+                lastElement = node.elements.at(-1);
 
             const openingBracketMustBeSpaced =
                 options.objectsInArraysException && isObjectType(firstElement) ||

package/lib/rules/block-scoped-var.js

@@ -79,7 +79,7 @@ module.exports = {
             }
 
             // Defines a predicate to check whether or not a given reference is outside of valid scope.
-            const scopeRange = stack[stack.length - 1];
+            const scopeRange = stack.at(-1);
 
             /**
              * Check if a reference is out of scope

package/lib/rules/callback-return.js

@@ -147,7 +147,7 @@ module.exports = {
                 if (closestBlock.type === "BlockStatement") {
 
                     // find the last item in the block
-                    const lastItem = closestBlock.body[closestBlock.body.length - 1];
+                    const lastItem = closestBlock.body.at(-1);
 
                     // if the callback is the last thing in a block that might be ok
                     if (isCallbackExpression(node, lastItem)) {
@@ -168,7 +168,7 @@ module.exports = {
                     if (lastItem.type === "ReturnStatement") {
 
                         // but only if the callback is immediately before
-                        if (isCallbackExpression(node, closestBlock.body[closestBlock.body.length - 2])) {
+                        if (isCallbackExpression(node, closestBlock.body.at(-2))) {
                             return;
                         }
                     }

package/lib/rules/camelcase.js

@@ -47,11 +47,9 @@ module.exports = {
                     },
                     allow: {
                         type: "array",
-                        items: [
-                            {
-                                type: "string"
-                            }
-                        ],
+                        items: {
+                            type: "string"
+                        },
                         minItems: 0,
                         uniqueItems: true
                     }

package/lib/rules/capitalized-comments.js

@@ -8,7 +8,6 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const LETTER_PATTERN = require("./utils/patterns/letters");
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -17,7 +16,8 @@ const astUtils = require("./utils/ast-utils");
 
 const DEFAULT_IGNORE_PATTERN = astUtils.COMMENTS_IGNORE_PATTERN,
     WHITESPACE = /\s/gu,
-    MAYBE_URL = /^\s*[^:/?#\s]+:\/\/[^?#]/u; // TODO: Combine w/ max-len pattern?
+    MAYBE_URL = /^\s*[^:/?#\s]+:\/\/[^?#]/u, // TODO: Combine w/ max-len pattern?
+    LETTER_PATTERN = /\p{L}/u;
 
 /*
  * Base schema body for defining the basic capitalization rule, ignorePattern,
@@ -233,7 +233,8 @@ module.exports = {
                 return true;
             }
 
-            const firstWordChar = commentWordCharsOnly[0];
+            // Get the first Unicode character (1 or 2 code units).
+            const [firstWordChar] = commentWordCharsOnly;
 
             if (!LETTER_PATTERN.test(firstWordChar)) {
                 return true;
@@ -273,12 +274,14 @@ module.exports = {
                     messageId,
                     fix(fixer) {
                         const match = comment.value.match(LETTER_PATTERN);
+                        const char = match[0];
 
-                        return fixer.replaceTextRange(
+                        // Offset match.index by 2 to account for the first 2 characters that start the comment (// or /*)
+                        const charIndex = comment.range[0] + match.index + 2;
 
-                            // Offset match.index by 2 to account for the first 2 characters that start the comment (// or /*)
-                            [comment.range[0] + match.index + 2, comment.range[0] + match.index + 3],
-                            capitalize === "always" ? match[0].toLocaleUpperCase() : match[0].toLocaleLowerCase()
+                        return fixer.replaceTextRange(
+                            [charIndex, charIndex + char.length],
+                            capitalize === "always" ? char.toLocaleUpperCase() : char.toLocaleLowerCase()
                         );
                     }
                 });

package/lib/rules/comma-dangle.js

@@ -154,7 +154,7 @@ module.exports = {
              * @returns {any} The last element
              */
             function last(array) {
-                return array[array.length - 1];
+                return array.at(-1);
             }
 
             switch (node.type) {

package/lib/rules/comma-style.js

@@ -66,7 +66,7 @@ module.exports = {
             NewExpression: true
         };
 
-        if (context.options.length === 2 && Object.prototype.hasOwnProperty.call(context.options[1], "exceptions")) {
+        if (context.options.length === 2 && Object.hasOwn(context.options[1], "exceptions")) {
             const keys = Object.keys(context.options[1].exceptions);
 
             for (let i = 0; i < keys.length; i++) {
@@ -218,7 +218,7 @@ module.exports = {
 
                         previousItemToken = tokenAfterItem
                             ? sourceCode.getTokenBefore(tokenAfterItem)
-                            : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];
+                            : sourceCode.ast.tokens.at(-1);
                     } else {
                         previousItemToken = currentItemToken;
                     }

package/lib/rules/complexity.js

@@ -64,7 +64,7 @@ module.exports = {
 
         if (
             typeof option === "object" &&
-            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
+            (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max"))
         ) {
             THRESHOLD = option.maximum || option.max;
         } else if (typeof option === "number") {
@@ -109,6 +109,7 @@ module.exports = {
             IfStatement: increaseComplexity,
             WhileStatement: increaseComplexity,
             DoWhileStatement: increaseComplexity,
+            AssignmentPattern: increaseComplexity,
 
             // Avoid `default`
             "SwitchCase[test]": increaseComplexity,
@@ -120,6 +121,18 @@ module.exports = {
                 }
             },
 
+            MemberExpression(node) {
+                if (node.optional === true) {
+                    increaseComplexity();
+                }
+            },
+
+            CallExpression(node) {
+                if (node.optional === true) {
+                    increaseComplexity();
+                }
+            },
+
             onCodePathEnd(codePath, node) {
                 const complexity = complexities.pop();
 

package/lib/rules/constructor-super.js

@@ -9,22 +9,6 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-
-    for (const segment of segments) {
-        if (segment.reachable) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 /**
  * Checks whether or not a given node is a constructor.
  * @param {ASTNode} node A node to check. This node type is one of
@@ -109,7 +93,7 @@ function isPossibleConstructor(node) {
             );
 
         case "SequenceExpression": {
-            const lastExpression = node.expressions[node.expressions.length - 1];
+            const lastExpression = node.expressions.at(-1);
 
             return isPossibleConstructor(lastExpression);
         }
@@ -119,6 +103,30 @@ function isPossibleConstructor(node) {
     }
 }
 
+/**
+ * A class to store information about a code path segment.
+ */
+class SegmentInfo {
+
+    /**
+     * Indicates if super() is called in all code paths.
+     * @type {boolean}
+     */
+    calledInEveryPaths = false;
+
+    /**
+     * Indicates if super() is called in any code paths.
+     * @type {boolean}
+     */
+    calledInSomePaths = false;
+
+    /**
+     * The nodes which have been validated and don't need to be reconsidered.
+     * @type {ASTNode[]}
+     */
+    validNodes = [];
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -141,8 +149,7 @@ module.exports = {
             missingAll: "Expected to call 'super()'.",
 
             duplicate: "Unexpected duplicate 'super()'.",
-            badSuper: "Unexpected 'super()' because 'super' is not a constructor.",
-            unexpected: "Unexpected 'super()'."
+            badSuper: "Unexpected 'super()' because 'super' is not a constructor."
         }
     },
 
@@ -159,14 +166,10 @@ module.exports = {
          */
         let funcInfo = null;
 
-        /*
-         * {Map<string, {calledInSomePaths: boolean, calledInEveryPaths: boolean}>}
-         * Information for each code path segment.
-         * - calledInSomePaths:  A flag of be called `super()` in some code paths.
-         * - calledInEveryPaths: A flag of be called `super()` in all code paths.
-         * - validNodes:
+        /**
+         * @type {Record<string, SegmentInfo>}
          */
-        let segInfoMap = Object.create(null);
+        const segInfoMap = Object.create(null);
 
         /**
          * Gets the flag which shows `super()` is called in some paths.
@@ -177,23 +180,21 @@ module.exports = {
             return segment.reachable && segInfoMap[segment.id].calledInSomePaths;
         }
 
+        /**
+         * Determines if a segment has been seen in the traversal.
+         * @param {CodePathSegment} segment A code path segment to check.
+         * @returns {boolean} `true` if the segment has been seen.
+         */
+        function hasSegmentBeenSeen(segment) {
+            return !!segInfoMap[segment.id];
+        }
+
         /**
          * Gets the flag which shows `super()` is called in all paths.
          * @param {CodePathSegment} segment A code path segment to get.
          * @returns {boolean} The flag which shows `super()` is called in all paths.
          */
         function isCalledInEveryPath(segment) {
-
-            /*
-             * If specific segment is the looped segment of the current segment,
-             * skip the segment.
-             * If not skipped, this never becomes true after a loop.
-             */
-            if (segment.nextSegments.length === 1 &&
-                segment.nextSegments[0].isLoopedPrevSegment(segment)
-            ) {
-                return true;
-            }
             return segment.reachable && segInfoMap[segment.id].calledInEveryPaths;
         }
 
@@ -250,9 +251,9 @@ module.exports = {
                 }
 
                 // Reports if `super()` lacked.
-                const segments = codePath.returnedSegments;
-                const calledInEveryPaths = segments.every(isCalledInEveryPath);
-                const calledInSomePaths = segments.some(isCalledInSomePath);
+                const returnedSegments = codePath.returnedSegments;
+                const calledInEveryPaths = returnedSegments.every(isCalledInEveryPath);
+                const calledInSomePaths = returnedSegments.some(isCalledInSomePath);
 
                 if (!calledInEveryPaths) {
                     context.report({
@@ -267,29 +268,37 @@ module.exports = {
             /**
              * Initialize information of a given code path segment.
              * @param {CodePathSegment} segment A code path segment to initialize.
+             * @param {CodePathSegment} node Node that starts the segment.
              * @returns {void}
              */
-            onCodePathSegmentStart(segment) {
+            onCodePathSegmentStart(segment, node) {
 
                 funcInfo.currentSegments.add(segment);
 
-                if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {
+                if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
 
                 // Initialize info.
-                const info = segInfoMap[segment.id] = {
-                    calledInSomePaths: false,
-                    calledInEveryPaths: false,
-                    validNodes: []
-                };
+                const info = segInfoMap[segment.id] = new SegmentInfo();
+
+                const seenPrevSegments = segment.prevSegments.filter(hasSegmentBeenSeen);
 
                 // When there are previous segments, aggregates these.
-                const prevSegments = segment.prevSegments;
+                if (seenPrevSegments.length > 0) {
+                    info.calledInSomePaths = seenPrevSegments.some(isCalledInSomePath);
+                    info.calledInEveryPaths = seenPrevSegments.every(isCalledInEveryPath);
+                }
 
-                if (prevSegments.length > 0) {
-                    info.calledInSomePaths = prevSegments.some(isCalledInSomePath);
-                    info.calledInEveryPaths = prevSegments.every(isCalledInEveryPath);
+                /*
+                 * ForStatement > *.update segments are a special case as they are created in advance,
+                 * without seen previous segments. Since they logically don't affect `calledInEveryPaths`
+                 * calculations, and they can never be a lone previous segment of another one, we'll set
+                 * their `calledInEveryPaths` to `true` to effectively ignore them in those calculations.
+                 * .
+                 */
+                if (node.parent && node.parent.type === "ForStatement" && node.parent.update === node) {
+                    info.calledInEveryPaths = true;
                 }
             },
 
@@ -316,25 +325,30 @@ module.exports = {
              * @returns {void}
              */
             onCodePathSegmentLoop(fromSegment, toSegment) {
-                if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {
+                if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
 
-                // Update information inside of the loop.
-                const isRealLoop = toSegment.prevSegments.length >= 2;
-
                 funcInfo.codePath.traverseSegments(
                     { first: toSegment, last: fromSegment },
-                    segment => {
+                    (segment, controller) => {
                         const info = segInfoMap[segment.id];
-                        const prevSegments = segment.prevSegments;
 
-                        // Updates flags.
-                        info.calledInSomePaths = prevSegments.some(isCalledInSomePath);
-                        info.calledInEveryPaths = prevSegments.every(isCalledInEveryPath);
+                        // skip segments after the loop
+                        if (!info) {
+                            controller.skip();
+                            return;
+                        }
+
+                        const seenPrevSegments = segment.prevSegments.filter(hasSegmentBeenSeen);
+                        const calledInSomePreviousPaths = seenPrevSegments.some(isCalledInSomePath);
+                        const calledInEveryPreviousPaths = seenPrevSegments.every(isCalledInEveryPath);
+
+                        info.calledInSomePaths ||= calledInSomePreviousPaths;
+                        info.calledInEveryPaths ||= calledInEveryPreviousPaths;
 
                         // If flags become true anew, reports the valid nodes.
-                        if (info.calledInSomePaths || isRealLoop) {
+                        if (calledInSomePreviousPaths) {
                             const nodes = info.validNodes;
 
                             info.validNodes = [];
@@ -358,7 +372,7 @@ module.exports = {
              * @returns {void}
              */
             "CallExpression:exit"(node) {
-                if (!(funcInfo && funcInfo.isConstructor)) {
+                if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
 
@@ -368,41 +382,34 @@ module.exports = {
                 }
 
                 // Reports if needed.
-                if (funcInfo.hasExtends) {
-                    const segments = funcInfo.currentSegments;
-                    let duplicate = false;
-                    let info = null;
+                const segments = funcInfo.currentSegments;
+                let duplicate = false;
+                let info = null;
 
-                    for (const segment of segments) {
+                for (const segment of segments) {
 
-                        if (segment.reachable) {
-                            info = segInfoMap[segment.id];
+                    if (segment.reachable) {
+                        info = segInfoMap[segment.id];
 
-                            duplicate = duplicate || info.calledInSomePaths;
-                            info.calledInSomePaths = info.calledInEveryPaths = true;
-                        }
+                        duplicate = duplicate || info.calledInSomePaths;
+                        info.calledInSomePaths = info.calledInEveryPaths = true;
                     }
+                }
 
-                    if (info) {
-                        if (duplicate) {
-                            context.report({
-                                messageId: "duplicate",
-                                node
-                            });
-                        } else if (!funcInfo.superIsConstructor) {
-                            context.report({
-                                messageId: "badSuper",
-                                node
-                            });
-                        } else {
-                            info.validNodes.push(node);
-                        }
+                if (info) {
+                    if (duplicate) {
+                        context.report({
+                            messageId: "duplicate",
+                            node
+                        });
+                    } else if (!funcInfo.superIsConstructor) {
+                        context.report({
+                            messageId: "badSuper",
+                            node
+                        });
+                    } else {
+                        info.validNodes.push(node);
                     }
-                } else if (isAnySegmentReachable(funcInfo.currentSegments)) {
-                    context.report({
-                        messageId: "unexpected",
-                        node
-                    });
                 }
             },
 
@@ -412,7 +419,7 @@ module.exports = {
              * @returns {void}
              */
             ReturnStatement(node) {
-                if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {
+                if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
 
@@ -432,14 +439,6 @@ module.exports = {
                         info.calledInSomePaths = info.calledInEveryPaths = true;
                     }
                 }
-            },
-
-            /**
-             * Resets state.
-             * @returns {void}
-             */
-            "Program:exit"() {
-                segInfoMap = Object.create(null);
             }
         };
     }

package/lib/rules/default-case.js

@@ -54,7 +54,7 @@ module.exports = {
          * @returns {any} Last element
          */
         function last(collection) {
-            return collection[collection.length - 1];
+            return collection.at(-1);
         }
 
         //--------------------------------------------------------------------------

package/lib/rules/eol-last.js

@@ -45,7 +45,7 @@ module.exports = {
             Program: function checkBadEOF(node) {
                 const sourceCode = context.sourceCode,
                     src = sourceCode.getText(),
-                    lastLine = sourceCode.lines[sourceCode.lines.length - 1],
+                    lastLine = sourceCode.lines.at(-1),
                     location = {
                         column: lastLine.length,
                         line: sourceCode.lines.length
@@ -89,7 +89,7 @@ module.exports = {
                     });
                 } else if (mode === "never" && endsWithNewline) {
 
-                    const secondLastLine = sourceCode.lines[sourceCode.lines.length - 2];
+                    const secondLastLine = sourceCode.lines.at(-2);
 
                     // File is newline-terminated, but shouldn't be
                     context.report({

package/lib/rules/function-paren-newline.js

@@ -218,7 +218,7 @@ module.exports = {
                 case "FunctionExpression": {
                     const leftParen = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
                     const rightParen = node.params.length
-                        ? sourceCode.getTokenAfter(node.params[node.params.length - 1], astUtils.isClosingParenToken)
+                        ? sourceCode.getTokenAfter(node.params.at(-1), astUtils.isClosingParenToken)
                         : sourceCode.getTokenAfter(leftParen);
 
                     return { leftParen, rightParen };
@@ -234,7 +234,7 @@ module.exports = {
                     }
 
                     const rightParen = node.params.length
-                        ? sourceCode.getTokenAfter(node.params[node.params.length - 1], astUtils.isClosingParenToken)
+                        ? sourceCode.getTokenAfter(node.params.at(-1), astUtils.isClosingParenToken)
                         : sourceCode.getTokenAfter(firstToken);
 
                     return {

package/lib/rules/indent-legacy.js

@@ -789,7 +789,7 @@ module.exports = {
             if (elements.length > 0) {
 
                 // Skip last block line check if last item in same line
-                if (elements[elements.length - 1].loc.end.line === node.loc.end.line) {
+                if (elements.at(-1).loc.end.line === node.loc.end.line) {
                     return;
                 }
             }
@@ -830,7 +830,7 @@ module.exports = {
             }
 
             let indent;
-            let nodesToCheck = [];
+            let nodesToCheck;
 
             /*
              * For this statements we should check indent from statement beginning,
@@ -873,7 +873,7 @@ module.exports = {
          */
         function filterOutSameLineVars(node) {
             return node.declarations.reduce((finalCollection, elem) => {
-                const lastElem = finalCollection[finalCollection.length - 1];
+                const lastElem = finalCollection.at(-1);
 
                 if ((elem.loc.start.line !== node.loc.start.line && !lastElem) ||
                     (lastElem && lastElem.loc.start.line !== elem.loc.start.line)) {
@@ -892,7 +892,7 @@ module.exports = {
         function checkIndentInVariableDeclarations(node) {
             const elements = filterOutSameLineVars(node);
             const nodeIndent = getNodeIndent(node).goodChar;
-            const lastElement = elements[elements.length - 1];
+            const lastElement = elements.at(-1);
 
             const elementsIndent = nodeIndent + indentSize * options.VariableDeclarator[node.kind];
 
@@ -999,7 +999,7 @@ module.exports = {
             },
 
             VariableDeclaration(node) {
-                if (node.declarations[node.declarations.length - 1].loc.start.line > node.declarations[0].loc.start.line) {
+                if (node.declarations.at(-1).loc.start.line > node.declarations[0].loc.start.line) {
                     checkIndentInVariableDeclarations(node);
                 }
             },

package/lib/rules/indent.js

@@ -1077,7 +1077,7 @@ module.exports = {
             "ObjectExpression, ObjectPattern"(node) {
                 const openingCurly = sourceCode.getFirstToken(node);
                 const closingCurly = sourceCode.getTokenAfter(
-                    node.properties.length ? node.properties[node.properties.length - 1] : openingCurly,
+                    node.properties.length ? node.properties.at(-1) : openingCurly,
                     astUtils.isClosingBraceToken
                 );
 
@@ -1407,7 +1407,7 @@ module.exports = {
             PropertyDefinition(node) {
                 const firstToken = sourceCode.getFirstToken(node);
                 const maybeSemicolonToken = sourceCode.getLastToken(node);
-                let keyLastToken = null;
+                let keyLastToken;
 
                 // Indent key.
                 if (node.computed) {
@@ -1458,7 +1458,7 @@ module.exports = {
 
                 if (node.cases.length) {
                     sourceCode.getTokensBetween(
-                        node.cases[node.cases.length - 1],
+                        node.cases.at(-1),
                         closingCurly,
                         { includeComments: true, filter: astUtils.isCommentToken }
                     ).forEach(token => offsets.ignoreToken(token));
@@ -1488,7 +1488,7 @@ module.exports = {
             },
 
             VariableDeclaration(node) {
-                let variableIndent = Object.prototype.hasOwnProperty.call(options.VariableDeclarator, node.kind)
+                let variableIndent = Object.hasOwn(options.VariableDeclarator, node.kind)
                     ? options.VariableDeclarator[node.kind]
                     : DEFAULT_VARIABLE_INDENT;
 
@@ -1509,7 +1509,7 @@ module.exports = {
                     variableIndent = DEFAULT_VARIABLE_INDENT;
                 }
 
-                if (node.declarations[node.declarations.length - 1].loc.start.line > node.loc.start.line) {
+                if (node.declarations.at(-1).loc.start.line > node.loc.start.line) {
 
                     /*
                      * VariableDeclarator indentation is a bit different from other forms of indentation, in that the

package/lib/rules/index.js

@@ -229,6 +229,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-unused-private-class-members": () => require("./no-unused-private-class-members"),
     "no-unused-vars": () => require("./no-unused-vars"),
     "no-use-before-define": () => require("./no-use-before-define"),
+    "no-useless-assignment": () => require("./no-useless-assignment"),
     "no-useless-backreference": () => require("./no-useless-backreference"),
     "no-useless-call": () => require("./no-useless-call"),
     "no-useless-catch": () => require("./no-useless-catch"),
@@ -273,7 +274,6 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     radix: () => require("./radix"),
     "require-atomic-updates": () => require("./require-atomic-updates"),
     "require-await": () => require("./require-await"),
-    "require-jsdoc": () => require("./require-jsdoc"),
     "require-unicode-regexp": () => require("./require-unicode-regexp"),
     "require-yield": () => require("./require-yield"),
     "rest-spread-spacing": () => require("./rest-spread-spacing"),
@@ -296,7 +296,6 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "template-tag-spacing": () => require("./template-tag-spacing"),
     "unicode-bom": () => require("./unicode-bom"),
     "use-isnan": () => require("./use-isnan"),
-    "valid-jsdoc": () => require("./valid-jsdoc"),
     "valid-typeof": () => require("./valid-typeof"),
     "vars-on-top": () => require("./vars-on-top"),
     "wrap-iife": () => require("./wrap-iife"),