eslint 8.57.0 → 9.2.0

package/lib/rules/no-useless-assignment.js

@@ -0,0 +1,566 @@
+/**
+ * @fileoverview A rule to disallow unnecessary assignments`.
+ * @author Yosuke Ota
+ */
+
+"use strict";
+
+const { findVariable } = require("@eslint-community/eslint-utils");
+
+//------------------------------------------------------------------------------
+// Types
+//------------------------------------------------------------------------------
+
+/** @typedef {import("estree").Node} ASTNode */
+/** @typedef {import("estree").Pattern} Pattern */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
+/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
+/** @typedef {import("estree").UpdateExpression} UpdateExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("eslint-scope").Variable} Variable */
+/** @typedef {import("../linter/code-path-analysis/code-path")} CodePath */
+/** @typedef {import("../linter/code-path-analysis/code-path-segment")} CodePathSegment */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Extract identifier from the given pattern node used on the left-hand side of the assignment.
+ * @param {Pattern} pattern The pattern node to extract identifier
+ * @returns {Iterable<Identifier>} The extracted identifier
+ */
+function *extractIdentifiersFromPattern(pattern) {
+    switch (pattern.type) {
+        case "Identifier":
+            yield pattern;
+            return;
+        case "ObjectPattern":
+            for (const property of pattern.properties) {
+                yield* extractIdentifiersFromPattern(property.type === "Property" ? property.value : property);
+            }
+            return;
+        case "ArrayPattern":
+            for (const element of pattern.elements) {
+                if (!element) {
+                    continue;
+                }
+                yield* extractIdentifiersFromPattern(element);
+            }
+            return;
+        case "RestElement":
+            yield* extractIdentifiersFromPattern(pattern.argument);
+            return;
+        case "AssignmentPattern":
+            yield* extractIdentifiersFromPattern(pattern.left);
+
+        // no default
+    }
+}
+
+
+/**
+ * Checks whether the given identifier node is evaluated after the assignment identifier.
+ * @param {AssignmentInfo} assignment The assignment info.
+ * @param {Identifier} identifier The identifier to check.
+ * @returns {boolean} `true` if the given identifier node is evaluated after the assignment identifier.
+ */
+function isIdentifierEvaluatedAfterAssignment(assignment, identifier) {
+    if (identifier.range[0] < assignment.identifier.range[1]) {
+        return false;
+    }
+    if (
+        assignment.expression &&
+        assignment.expression.range[0] <= identifier.range[0] &&
+        identifier.range[1] <= assignment.expression.range[1]
+    ) {
+
+        /*
+         * The identifier node is in an expression that is evaluated before the assignment.
+         * e.g. x = id;
+         *          ^^ identifier to check
+         *      ^      assignment identifier
+         */
+        return false;
+    }
+
+    /*
+     * e.g.
+     *      x = 42; id;
+     *              ^^ identifier to check
+     *      ^          assignment identifier
+     *      let { x, y = id } = obj;
+     *                   ^^  identifier to check
+     *            ^          assignment identifier
+     */
+    return true;
+}
+
+/**
+ * Checks whether the given identifier node is used between the assigned identifier and the equal sign.
+ *
+ * e.g. let { x, y = x } = obj;
+ *                   ^   identifier to check
+ *            ^          assigned identifier
+ * @param {AssignmentInfo} assignment The assignment info.
+ * @param {Identifier} identifier The identifier to check.
+ * @returns {boolean} `true` if the given identifier node is used between the assigned identifier and the equal sign.
+ */
+function isIdentifierUsedBetweenAssignedAndEqualSign(assignment, identifier) {
+    if (!assignment.expression) {
+        return false;
+    }
+    return (
+        assignment.identifier.range[1] <= identifier.range[0] &&
+        identifier.range[1] <= assignment.expression.range[0]
+    );
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow variable assignments when the value is not used",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-useless-assignment"
+        },
+
+        schema: [],
+
+        messages: {
+            unnecessaryAssignment: "This assigned value is not used in subsequent statements."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        /**
+         * @typedef {Object} ScopeStack
+         * @property {CodePath} codePath The code path of this scope stack.
+         * @property {Scope} scope The scope of this scope stack.
+         * @property {ScopeStack} upper The upper scope stack.
+         * @property {Record<string, ScopeStackSegmentInfo>} segments The map of ScopeStackSegmentInfo.
+         * @property {Set<CodePathSegment>} currentSegments The current CodePathSegments.
+         * @property {Map<Variable, AssignmentInfo[]>} assignments The map of list of AssignmentInfo for each variable.
+         */
+        /**
+         * @typedef {Object} ScopeStackSegmentInfo
+         * @property {CodePathSegment} segment The code path segment.
+         * @property {Identifier|null} first The first identifier that appears within the segment.
+         * @property {Identifier|null} last The last identifier that appears within the segment.
+         * `first` and `last` are used to determine whether an identifier exists within the segment position range.
+         * Since it is used as a range of segments, we should originally hold all nodes, not just identifiers,
+         * but since the only nodes to be judged are identifiers, it is sufficient to have a range of identifiers.
+         */
+        /**
+         * @typedef {Object} AssignmentInfo
+         * @property {Variable} variable The variable that is assigned.
+         * @property {Identifier} identifier The identifier that is assigned.
+         * @property {VariableDeclarator|AssignmentExpression|UpdateExpression} node The node where the variable was updated.
+         * @property {Expression|null} expression The expression that is evaluated before the assignment.
+         * @property {CodePathSegment[]} segments The code path segments where the assignment was made.
+         */
+
+        /** @type {ScopeStack} */
+        let scopeStack = null;
+
+        /** @type {Set<Scope>} */
+        const codePathStartScopes = new Set();
+
+        /**
+         * Gets the scope of code path start from given scope
+         * @param {Scope} scope The initial scope
+         * @returns {Scope} The scope of code path start
+         * @throws {Error} Unexpected error
+         */
+        function getCodePathStartScope(scope) {
+            let target = scope;
+
+            while (target) {
+                if (codePathStartScopes.has(target)) {
+                    return target;
+                }
+                target = target.upper;
+            }
+
+            // Should be unreachable
+            return null;
+        }
+
+        /**
+         * Verify the given scope stack.
+         * @param {ScopeStack} target The scope stack to verify.
+         * @returns {void}
+         */
+        function verify(target) {
+
+            /**
+             * Checks whether the given identifier is used in the segment.
+             * @param {CodePathSegment} segment The code path segment.
+             * @param {Identifier} identifier The identifier to check.
+             * @returns {boolean} `true` if the identifier is used in the segment.
+             */
+            function isIdentifierUsedInSegment(segment, identifier) {
+                const segmentInfo = target.segments[segment.id];
+
+                return (
+                    segmentInfo.first &&
+                    segmentInfo.last &&
+                    segmentInfo.first.range[0] <= identifier.range[0] &&
+                    identifier.range[1] <= segmentInfo.last.range[1]
+                );
+            }
+
+            /**
+             * Verifies whether the given assignment info is an used assignment.
+             * Report if it is an unused assignment.
+             * @param {AssignmentInfo} targetAssignment The assignment info to verify.
+             * @param {AssignmentInfo[]} allAssignments The list of all assignment info for variables.
+             * @returns {void}
+             */
+            function verifyAssignmentIsUsed(targetAssignment, allAssignments) {
+
+                /**
+                 * @typedef {Object} SubsequentSegmentData
+                 * @property {CodePathSegment} segment The code path segment
+                 * @property {AssignmentInfo} [assignment] The first occurrence of the assignment within the segment.
+                 * There is no need to check if the variable is used after this assignment,
+                 * as the value it was assigned will be used.
+                 */
+
+                /**
+                 * Information used in `getSubsequentSegments()`.
+                 * To avoid unnecessary iterations, cache information that has already been iterated over,
+                 * and if additional iterations are needed, start iterating from the retained position.
+                 */
+                const subsequentSegmentData = {
+
+                    /**
+                     * Cache of subsequent segment information list that have already been iterated.
+                     * @type {SubsequentSegmentData[]}
+                     */
+                    results: [],
+
+                    /**
+                     * Subsequent segments that have already been iterated on. Used to avoid infinite loops.
+                     * @type {Set<CodePathSegment>}
+                     */
+                    subsequentSegments: new Set(),
+
+                    /**
+                     * Unexplored code path segment.
+                     * If additional iterations are needed, consume this information and iterate.
+                     * @type {CodePathSegment[]}
+                     */
+                    queueSegments: targetAssignment.segments.flatMap(segment => segment.nextSegments)
+                };
+
+
+                /**
+                 * Gets the subsequent segments from the segment of
+                 * the assignment currently being validated (targetAssignment).
+                 * @returns {Iterable<SubsequentSegmentData>} the subsequent segments
+                 */
+                function *getSubsequentSegments() {
+                    yield* subsequentSegmentData.results;
+
+                    while (subsequentSegmentData.queueSegments.length > 0) {
+                        const nextSegment = subsequentSegmentData.queueSegments.shift();
+
+                        if (subsequentSegmentData.subsequentSegments.has(nextSegment)) {
+                            continue;
+                        }
+                        subsequentSegmentData.subsequentSegments.add(nextSegment);
+
+                        const assignmentInSegment = allAssignments
+                            .find(otherAssignment => (
+                                otherAssignment.segments.includes(nextSegment) &&
+                                !isIdentifierUsedBetweenAssignedAndEqualSign(otherAssignment, targetAssignment.identifier)
+                            ));
+
+                        if (!assignmentInSegment) {
+
+                            /*
+                             * Stores the next segment to explore.
+                             * If `assignmentInSegment` exists,
+                             * we are guarding it because we don't need to explore the next segment.
+                             */
+                            subsequentSegmentData.queueSegments.push(...nextSegment.nextSegments);
+                        }
+
+                        /** @type {SubsequentSegmentData} */
+                        const result = {
+                            segment: nextSegment,
+                            assignment: assignmentInSegment
+                        };
+
+                        subsequentSegmentData.results.push(result);
+                        yield result;
+                    }
+                }
+
+
+                const readReferences = targetAssignment.variable.references.filter(reference => reference.isRead());
+
+                if (!readReferences.length) {
+
+                    /*
+                     * It is not just an unnecessary assignment, but an unnecessary (unused) variable
+                     * and thus should not be reported by this rule because it is reported by `no-unused-vars`.
+                     */
+                    return;
+                }
+
+                /**
+                 * Other assignment on the current segment and after current assignment.
+                 */
+                const otherAssignmentAfterTargetAssignment = allAssignments
+                    .find(assignment => {
+                        if (
+                            assignment === targetAssignment ||
+                            assignment.segments.length && assignment.segments.every(segment => !targetAssignment.segments.includes(segment))
+                        ) {
+                            return false;
+                        }
+                        if (isIdentifierEvaluatedAfterAssignment(targetAssignment, assignment.identifier)) {
+                            return true;
+                        }
+                        if (
+                            assignment.expression &&
+                            assignment.expression.range[0] <= targetAssignment.identifier.range[0] &&
+                            targetAssignment.identifier.range[1] <= assignment.expression.range[1]
+                        ) {
+
+                            /*
+                             * The target assignment is in an expression that is evaluated before the assignment.
+                             * e.g. x=(x=1);
+                             *         ^^^ targetAssignment
+                             *      ^^^^^^^ assignment
+                             */
+                            return true;
+                        }
+
+                        return false;
+                    });
+
+                for (const reference of readReferences) {
+
+                    /*
+                     * If the scope of the reference is outside the current code path scope,
+                     * we cannot track whether this assignment is not used.
+                     * For example, it can also be called asynchronously.
+                     */
+                    if (target.scope !== getCodePathStartScope(reference.from)) {
+                        return;
+                    }
+
+                    // Checks if it is used in the same segment as the target assignment.
+                    if (
+                        isIdentifierEvaluatedAfterAssignment(targetAssignment, reference.identifier) &&
+                        (
+                            isIdentifierUsedBetweenAssignedAndEqualSign(targetAssignment, reference.identifier) ||
+                            targetAssignment.segments.some(segment => isIdentifierUsedInSegment(segment, reference.identifier))
+                        )
+                    ) {
+
+                        if (
+                            otherAssignmentAfterTargetAssignment &&
+                            isIdentifierEvaluatedAfterAssignment(otherAssignmentAfterTargetAssignment, reference.identifier)
+                        ) {
+
+                            // There was another assignment before the reference. Therefore, it has not been used yet.
+                            continue;
+                        }
+
+                        // Uses in statements after the written identifier.
+                        return;
+                    }
+
+                    if (otherAssignmentAfterTargetAssignment) {
+
+                        /*
+                         * The assignment was followed by another assignment in the same segment.
+                         * Therefore, there is no need to check the next segment.
+                         */
+                        continue;
+                    }
+
+                    // Check subsequent segments.
+                    for (const subsequentSegment of getSubsequentSegments()) {
+                        if (isIdentifierUsedInSegment(subsequentSegment.segment, reference.identifier)) {
+                            if (
+                                subsequentSegment.assignment &&
+                                isIdentifierEvaluatedAfterAssignment(subsequentSegment.assignment, reference.identifier)
+                            ) {
+
+                                // There was another assignment before the reference. Therefore, it has not been used yet.
+                                continue;
+                            }
+
+                            // It is used
+                            return;
+                        }
+                    }
+                }
+                context.report({
+                    node: targetAssignment.identifier,
+                    messageId: "unnecessaryAssignment"
+                });
+            }
+
+            // Verify that each assignment in the code path is used.
+            for (const assignments of target.assignments.values()) {
+                assignments.sort((a, b) => a.identifier.range[0] - b.identifier.range[0]);
+                for (const assignment of assignments) {
+                    verifyAssignmentIsUsed(assignment, assignments);
+                }
+            }
+        }
+
+        return {
+            onCodePathStart(codePath, node) {
+                const scope = sourceCode.getScope(node);
+
+                scopeStack = {
+                    upper: scopeStack,
+                    codePath,
+                    scope,
+                    segments: Object.create(null),
+                    currentSegments: new Set(),
+                    assignments: new Map()
+                };
+                codePathStartScopes.add(scopeStack.scope);
+            },
+            onCodePathEnd() {
+                verify(scopeStack);
+
+                scopeStack = scopeStack.upper;
+            },
+            onCodePathSegmentStart(segment) {
+                const segmentInfo = { segment, first: null, last: null };
+
+                scopeStack.segments[segment.id] = segmentInfo;
+                scopeStack.currentSegments.add(segment);
+            },
+            onCodePathSegmentEnd(segment) {
+                scopeStack.currentSegments.delete(segment);
+            },
+            Identifier(node) {
+                for (const segment of scopeStack.currentSegments) {
+                    const segmentInfo = scopeStack.segments[segment.id];
+
+                    if (!segmentInfo.first) {
+                        segmentInfo.first = node;
+                    }
+                    segmentInfo.last = node;
+                }
+            },
+            ":matches(VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression):exit"(node) {
+                if (scopeStack.currentSegments.size === 0) {
+
+                    // Ignore unreachable segments
+                    return;
+                }
+
+                const assignments = scopeStack.assignments;
+
+                let pattern;
+                let expression = null;
+
+                if (node.type === "VariableDeclarator") {
+                    pattern = node.id;
+                    expression = node.init;
+                } else if (node.type === "AssignmentExpression") {
+                    pattern = node.left;
+                    expression = node.right;
+                } else { // UpdateExpression
+                    pattern = node.argument;
+                }
+
+                for (const identifier of extractIdentifiersFromPattern(pattern)) {
+                    const scope = sourceCode.getScope(identifier);
+
+                    /** @type {Variable} */
+                    const variable = findVariable(scope, identifier);
+
+                    if (!variable) {
+                        continue;
+                    }
+
+                    // We don't know where global variables are used.
+                    if (variable.scope.type === "global" && variable.defs.length === 0) {
+                        continue;
+                    }
+
+                    /*
+                     * If the scope of the variable is outside the current code path scope,
+                     * we cannot track whether this assignment is not used.
+                     */
+                    if (scopeStack.scope !== getCodePathStartScope(variable.scope)) {
+                        continue;
+                    }
+
+                    // Variables marked by `markVariableAsUsed()` or
+                    // exported by "exported" block comment.
+                    if (variable.eslintUsed) {
+                        continue;
+                    }
+
+                    // Variables exported by ESM export syntax
+                    if (variable.scope.type === "module") {
+                        if (
+                            variable.defs
+                                .some(def => (
+                                    (def.type === "Variable" && def.parent.parent.type === "ExportNamedDeclaration") ||
+                                    (
+                                        def.type === "FunctionName" &&
+                                        (
+                                            def.node.parent.type === "ExportNamedDeclaration" ||
+                                            def.node.parent.type === "ExportDefaultDeclaration"
+                                        )
+                                    ) ||
+                                    (
+                                        def.type === "ClassName" &&
+                                        (
+                                            def.node.parent.type === "ExportNamedDeclaration" ||
+                                            def.node.parent.type === "ExportDefaultDeclaration"
+                                        )
+                                    )
+                                ))
+                        ) {
+                            continue;
+                        }
+                        if (variable.references.some(reference => reference.identifier.parent.type === "ExportSpecifier")) {
+
+                            // It have `export { ... }` reference.
+                            continue;
+                        }
+                    }
+
+                    let list = assignments.get(variable);
+
+                    if (!list) {
+                        list = [];
+                        assignments.set(variable, list);
+                    }
+                    list.push({
+                        variable,
+                        identifier,
+                        node,
+                        expression,
+                        segments: [...scopeStack.currentSegments]
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/no-useless-backreference.js

@@ -138,7 +138,7 @@ module.exports = {
 
                             // the opposite of the previous when the regex is matching backward in a lookbehind context.
                             messageId = "backward";
-                        } else if (groupCut[groupCut.length - 1].type === "Alternative") {
+                        } else if (groupCut.at(-1).type === "Alternative") {
 
                             // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
                             messageId = "disjunctive";

package/lib/rules/no-useless-computed-key.js

@@ -101,7 +101,7 @@ module.exports = {
             properties: {
                 enforceForClassMembers: {
                     type: "boolean",
-                    default: false
+                    default: true
                 }
             },
             additionalProperties: false
@@ -114,7 +114,7 @@ module.exports = {
     },
     create(context) {
         const sourceCode = context.sourceCode;
-        const enforceForClassMembers = context.options[0] && context.options[0].enforceForClassMembers;
+        const enforceForClassMembers = context.options[0]?.enforceForClassMembers ?? true;
 
         /**
          * Reports a given node if it violated this rule.

package/lib/rules/no-useless-return.js

@@ -146,7 +146,9 @@ module.exports = {
                     continue;
                 }
 
-                uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);
+                if (segmentInfoMap.has(segment)) {
+                    uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);
+                }
             }
 
             return uselessReturns;
@@ -182,6 +184,10 @@ module.exports = {
 
             const info = segmentInfoMap.get(segment);
 
+            if (!info) {
+                return;
+            }
+
             info.uselessReturns = info.uselessReturns.filter(node => {
                 if (scopeInfo.traversedTryBlockStatements && scopeInfo.traversedTryBlockStatements.length > 0) {
                     const returnInitialRange = node.range[0];
@@ -275,7 +281,6 @@ module.exports = {
              * NOTE: This event is notified for only reachable segments.
              */
             onCodePathSegmentStart(segment) {
-
                 scopeInfo.currentSegments.add(segment);
 
                 const info = {

package/lib/rules/object-curly-spacing.js

@@ -217,7 +217,7 @@ module.exports = {
          * @returns {Token} '}' token.
          */
         function getClosingBraceOfObject(node) {
-            const lastProperty = node.properties[node.properties.length - 1];
+            const lastProperty = node.properties.at(-1);
 
             return sourceCode.getTokenAfter(lastProperty, astUtils.isClosingBraceToken);
         }
@@ -251,7 +251,7 @@ module.exports = {
             }
 
             let firstSpecifier = node.specifiers[0];
-            const lastSpecifier = node.specifiers[node.specifiers.length - 1];
+            const lastSpecifier = node.specifiers.at(-1);
 
             if (lastSpecifier.type !== "ImportSpecifier") {
                 return;
@@ -279,7 +279,7 @@ module.exports = {
             }
 
             const firstSpecifier = node.specifiers[0],
-                lastSpecifier = node.specifiers[node.specifiers.length - 1],
+                lastSpecifier = node.specifiers.at(-1),
                 first = sourceCode.getTokenBefore(firstSpecifier),
                 last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken),
                 second = sourceCode.getTokenAfter(first, { includeComments: true }),

package/lib/rules/object-property-newline.js

@@ -63,7 +63,7 @@ module.exports = {
                 if (allowSameLine) {
                     if (node.properties.length > 1) {
                         const firstTokenOfFirstProperty = sourceCode.getFirstToken(node.properties[0]);
-                        const lastTokenOfLastProperty = sourceCode.getLastToken(node.properties[node.properties.length - 1]);
+                        const lastTokenOfLastProperty = sourceCode.getLastToken(node.properties.at(-1));
 
                         if (firstTokenOfFirstProperty.loc.end.line === lastTokenOfLastProperty.loc.start.line) {