eslint 8.57.0 → 9.2.0

package/lib/linter/apply-disable-directives.js

@@ -16,6 +16,11 @@
 //------------------------------------------------------------------------------
 
 const escapeRegExp = require("escape-string-regexp");
+const {
+    Legacy: {
+        ConfigOps
+    }
+} = require("@eslint/eslintrc/universal");
 
 /**
  * Compares the locations of two objects in a source file
@@ -33,16 +38,16 @@ function compareLocations(itemA, itemB) {
  * @param {Iterable<Directive>} directives Unused directives to be removed.
  * @returns {Directive[][]} Directives grouped by their parent comment.
  */
-function groupByParentComment(directives) {
+function groupByParentDirective(directives) {
     const groups = new Map();
 
     for (const directive of directives) {
-        const { unprocessedDirective: { parentComment } } = directive;
+        const { unprocessedDirective: { parentDirective } } = directive;
 
-        if (groups.has(parentComment)) {
-            groups.get(parentComment).push(directive);
+        if (groups.has(parentDirective)) {
+            groups.get(parentDirective).push(directive);
         } else {
-            groups.set(parentComment, [directive]);
+            groups.set(parentDirective, [directive]);
         }
     }
 
@@ -52,19 +57,19 @@ function groupByParentComment(directives) {
 /**
  * Creates removal details for a set of directives within the same comment.
  * @param {Directive[]} directives Unused directives to be removed.
- * @param {Token} commentToken The backing Comment token.
+ * @param {Token} node The backing Comment token.
  * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems.
  */
-function createIndividualDirectivesRemoval(directives, commentToken) {
+function createIndividualDirectivesRemoval(directives, node) {
 
     /*
-     * `commentToken.value` starts right after `//` or `/*`.
+     * `node.value` starts right after `//` or `/*`.
      * All calculated offsets will be relative to this index.
      */
-    const commentValueStart = commentToken.range[0] + "//".length;
+    const commentValueStart = node.range[0] + "//".length;
 
     // Find where the list of rules starts. `\S+` matches with the directive name (e.g. `eslint-disable-line`)
-    const listStartOffset = /^\s*\S+\s+/u.exec(commentToken.value)[0].length;
+    const listStartOffset = /^\s*\S+\s+/u.exec(node.value)[0].length;
 
     /*
      * Get the list text without any surrounding whitespace. In order to preserve the original
@@ -73,7 +78,7 @@ function createIndividualDirectivesRemoval(directives, commentToken) {
      *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
      *                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      */
-    const listText = commentToken.value
+    const listText = node.value
         .slice(listStartOffset) // remove directive name and all whitespace before the list
         .split(/\s-{2,}\s/u)[0] // remove `-- comment`, if it exists
         .trimEnd(); // remove all whitespace after the list
@@ -154,19 +159,19 @@ function createIndividualDirectivesRemoval(directives, commentToken) {
 }
 
 /**
- * Creates a description of deleting an entire unused disable comment.
+ * Creates a description of deleting an entire unused disable directive.
  * @param {Directive[]} directives Unused directives to be removed.
- * @param {Token} commentToken The backing Comment token.
- * @returns {{ description, fix, unprocessedDirective }} Details for later creation of an output Problem.
+ * @param {Token} node The backing Comment token.
+ * @returns {{ description, fix, unprocessedDirective }} Details for later creation of an output problem.
  */
-function createCommentRemoval(directives, commentToken) {
-    const { range } = commentToken;
+function createDirectiveRemoval(directives, node) {
+    const { range } = node;
     const ruleIds = directives.filter(directive => directive.ruleId).map(directive => `'${directive.ruleId}'`);
 
     return {
         description: ruleIds.length <= 2
             ? ruleIds.join(" or ")
-            : `${ruleIds.slice(0, ruleIds.length - 1).join(", ")}, or ${ruleIds[ruleIds.length - 1]}`,
+            : `${ruleIds.slice(0, ruleIds.length - 1).join(", ")}, or ${ruleIds.at(-1)}`,
         fix: {
             range,
             text: " "
@@ -181,20 +186,20 @@ function createCommentRemoval(directives, commentToken) {
  * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems.
  */
 function processUnusedDirectives(allDirectives) {
-    const directiveGroups = groupByParentComment(allDirectives);
+    const directiveGroups = groupByParentDirective(allDirectives);
 
     return directiveGroups.flatMap(
         directives => {
-            const { parentComment } = directives[0].unprocessedDirective;
-            const remainingRuleIds = new Set(parentComment.ruleIds);
+            const { parentDirective } = directives[0].unprocessedDirective;
+            const remainingRuleIds = new Set(parentDirective.ruleIds);
 
             for (const directive of directives) {
                 remainingRuleIds.delete(directive.ruleId);
             }
 
             return remainingRuleIds.size
-                ? createIndividualDirectivesRemoval(directives, parentComment.commentToken)
-                : [createCommentRemoval(directives, parentComment.commentToken)];
+                ? createIndividualDirectivesRemoval(directives, parentDirective.node)
+                : [createDirectiveRemoval(directives, parentDirective.node)];
         }
     );
 }
@@ -337,7 +342,7 @@ function applyDirectives(options) {
                 problem.suppressions = problem.suppressions.concat(suppressions);
             } else {
                 problem.suppressions = suppressions;
-                usedDisableDirectives.add(disableDirectivesForProblem[disableDirectivesForProblem.length - 1]);
+                usedDisableDirectives.add(disableDirectivesForProblem.at(-1));
             }
         }
 
@@ -345,11 +350,11 @@ function applyDirectives(options) {
     }
 
     const unusedDisableDirectivesToReport = options.directives
-        .filter(directive => directive.type === "disable" && !usedDisableDirectives.has(directive));
+        .filter(directive => directive.type === "disable" && !usedDisableDirectives.has(directive) && !options.rulesToIgnore.has(directive.ruleId));
 
 
     const unusedEnableDirectivesToReport = new Set(
-        options.directives.filter(directive => directive.unprocessedDirective.type === "enable")
+        options.directives.filter(directive => directive.unprocessedDirective.type === "enable" && !options.rulesToIgnore.has(directive.ruleId))
     );
 
     /*
@@ -367,7 +372,7 @@ function applyDirectives(options) {
 
     const unusedDirectives = processed
         .map(({ description, fix, unprocessedDirective }) => {
-            const { parentComment, type, line, column } = unprocessedDirective;
+            const { parentDirective, type, line, column } = unprocessedDirective;
 
             let message;
 
@@ -383,8 +388,8 @@ function applyDirectives(options) {
             return {
                 ruleId: null,
                 message,
-                line: type === "disable-next-line" ? parentComment.commentToken.loc.start.line : line,
-                column: type === "disable-next-line" ? parentComment.commentToken.loc.start.column + 1 : column,
+                line: type === "disable-next-line" ? parentDirective.node.loc.start.line : line,
+                column: type === "disable-next-line" ? parentDirective.node.loc.start.column + 1 : column,
                 severity: options.reportUnusedDisableDirectives === "warn" ? 1 : 2,
                 nodeType: null,
                 ...options.disableFixes ? {} : { fix }
@@ -410,11 +415,13 @@ function applyDirectives(options) {
  * @param {{ruleId: (string|null), line: number, column: number}[]} options.problems
  * A list of problems reported by rules, sorted by increasing location in the file, with one-based columns.
  * @param {"off" | "warn" | "error"} options.reportUnusedDisableDirectives If `"warn"` or `"error"`, adds additional problems for unused directives
+ * @param {Object} options.configuredRules The rules configuration.
+ * @param {Function} options.ruleFilter A predicate function to filter which rules should be executed.
  * @param {boolean} options.disableFixes If true, it doesn't make `fix` properties.
  * @returns {{ruleId: (string|null), line: number, column: number, suppressions?: {kind: string, justification: string}}[]}
  * An object with a list of reported problems, the suppressed of which contain the suppression information.
  */
-module.exports = ({ directives, disableFixes, problems, reportUnusedDisableDirectives = "off" }) => {
+module.exports = ({ directives, disableFixes, problems, configuredRules, ruleFilter, reportUnusedDisableDirectives = "off" }) => {
     const blockDirectives = directives
         .filter(directive => directive.type === "disable" || directive.type === "enable")
         .map(directive => Object.assign({}, directive, { unprocessedDirective: directive }))
@@ -443,17 +450,38 @@ module.exports = ({ directives, disableFixes, problems, reportUnusedDisableDirec
         }
     }).sort(compareLocations);
 
+    // This determines a list of rules that are not being run by the given ruleFilter, if present.
+    const rulesToIgnore = configuredRules && ruleFilter
+        ? new Set(Object.keys(configuredRules).filter(ruleId => {
+            const severity = ConfigOps.getRuleSeverity(configuredRules[ruleId]);
+
+            // Ignore for disabled rules.
+            if (severity === 0) {
+                return false;
+            }
+
+            return !ruleFilter({ severity, ruleId });
+        }))
+        : new Set();
+
+    // If no ruleId is supplied that means this directive is applied to all rules, so we can't determine if it's unused if any rules are filtered out.
+    if (rulesToIgnore.size > 0) {
+        rulesToIgnore.add(null);
+    }
+
     const blockDirectivesResult = applyDirectives({
         problems,
         directives: blockDirectives,
         disableFixes,
-        reportUnusedDisableDirectives
+        reportUnusedDisableDirectives,
+        rulesToIgnore
     });
     const lineDirectivesResult = applyDirectives({
         problems: blockDirectivesResult.problems,
         directives: lineDirectives,
         disableFixes,
-        reportUnusedDisableDirectives
+        reportUnusedDisableDirectives,
+        rulesToIgnore
     });
 
     return reportUnusedDisableDirectives !== "off"

package/lib/linter/code-path-analysis/code-path-analyzer.js

@@ -222,7 +222,6 @@ function forwardCurrentToHead(analyzer, node) {
                 : "onUnreachableCodePathSegmentStart";
 
             debug.dump(`${eventName} ${headSegment.id}`);
-
             CodePathSegment.markUsed(headSegment);
             analyzer.emitter.emit(
                 eventName,

package/lib/linter/code-path-analysis/code-path.js

@@ -125,20 +125,6 @@ class CodePath {
         return this.internal.thrownForkContext;
     }
 
-    /**
-     * Tracks the traversal of the code path through each segment. This array
-     * starts empty and segments are added or removed as the code path is
-     * traversed. This array always ends up empty at the end of a code path
-     * traversal. The `CodePathState` uses this to track its progress through
-     * the code path.
-     * This is a passthrough to the underlying `CodePathState`.
-     * @type {CodePathSegment[]}
-     * @deprecated
-     */
-    get currentSegments() {
-        return this.internal.currentSegments;
-    }
-
     /**
      * Traverses all segments in this code path.
      *
@@ -180,9 +166,9 @@ class CodePath {
         const lastSegment = resolvedOptions.last;
 
         // set up initial location information
-        let record = null;
-        let index = 0;
-        let end = 0;
+        let record;
+        let index;
+        let end;
         let segment = null;
 
         // segments that have already been visited during traversal
@@ -191,8 +177,8 @@ class CodePath {
         // tracks the traversal steps
         const stack = [[startSegment, 0]];
 
-        // tracks the last skipped segment during traversal
-        let skippedSegment = null;
+        // segments that have been skipped during traversal
+        const skipped = new Set();
 
         // indicates if we exited early from the traversal
         let broken = false;
@@ -207,11 +193,7 @@ class CodePath {
              * @returns {void}
              */
             skip() {
-                if (stack.length <= 1) {
-                    broken = true;
-                } else {
-                    skippedSegment = stack[stack.length - 2][0];
-                }
+                skipped.add(segment);
             },
 
             /**
@@ -236,6 +218,18 @@ class CodePath {
             );
         }
 
+        /**
+         * Checks if a given previous segment has been skipped.
+         * @param {CodePathSegment} prevSegment A previous segment to check.
+         * @returns {boolean} `true` if the segment has been skipped.
+         */
+        function isSkipped(prevSegment) {
+            return (
+                skipped.has(prevSegment) ||
+                segment.isLoopedPrevSegment(prevSegment)
+            );
+        }
+
         // the traversal
         while (stack.length > 0) {
 
@@ -251,7 +245,7 @@ class CodePath {
              * Otherwise, we just read the value and sometimes modify the
              * record as we traverse.
              */
-            record = stack[stack.length - 1];
+            record = stack.at(-1);
             segment = record[0];
             index = record[1];
 
@@ -272,17 +266,21 @@ class CodePath {
                     continue;
                 }
 
-                // Reset the skipping flag if all branches have been skipped.
-                if (skippedSegment && segment.prevSegments.includes(skippedSegment)) {
-                    skippedSegment = null;
-                }
                 visited.add(segment);
 
+
+                // Skips the segment if all previous segments have been skipped.
+                const shouldSkip = (
+                    skipped.size > 0 &&
+                    segment.prevSegments.length > 0 &&
+                    segment.prevSegments.every(isSkipped)
+                );
+
                 /*
                  * If the most recent segment hasn't been skipped, then we call
                  * the callback, passing in the segment and the controller.
                  */
-                if (!skippedSegment) {
+                if (!shouldSkip) {
                     resolvedCallback.call(this, segment, controller);
 
                     // exit if we're at the last segment
@@ -298,6 +296,10 @@ class CodePath {
                     if (broken) {
                         break;
                     }
+                } else {
+
+                    // If the most recent segment has been skipped, then mark it as skipped.
+                    skipped.add(segment);
                 }
             }
 

package/lib/linter/code-path-analysis/fork-context.js

@@ -207,7 +207,7 @@ class ForkContext {
     get head() {
         const list = this.segmentsList;
 
-        return list.length === 0 ? [] : list[list.length - 1];
+        return list.length === 0 ? [] : list.at(-1);
     }
 
     /**

package/lib/linter/config-comment-parser.js

@@ -40,7 +40,7 @@ module.exports = class ConfigCommentParser {
 
     /**
      * Parses a list of "name:string_value" or/and "name" options divided by comma or
-     * whitespace. Used for "global" and "exported" comments.
+     * whitespace. Used for "global" comments.
      * @param {string} string The string to parse.
      * @param {Comment} comment The comment node which has the string.
      * @returns {Object} Result map object of names and string values, or null values if no value was provided
@@ -75,11 +75,9 @@ module.exports = class ConfigCommentParser {
     parseJsonConfig(string, location) {
         debug("Parsing JSON config");
 
-        let items = {};
-
         // Parses a JSON-like comment by the same way as parsing CLI option.
         try {
-            items = levn.parse("Object", string) || {};
+            const items = levn.parse("Object", string) || {};
 
             // Some tests say that it should ignore invalid comments such as `/*eslint no-alert:abc*/`.
             // Also, commaless notations have invalid severity:
@@ -102,11 +100,15 @@ module.exports = class ConfigCommentParser {
          * Optionator cannot parse commaless notations.
          * But we are supporting that. So this is a fallback for that.
          */
-        items = {};
         const normalizedString = string.replace(/([-a-zA-Z0-9/]+):/gu, "\"$1\":").replace(/(\]|[0-9])\s+(?=")/u, "$1,");
 
         try {
-            items = JSON.parse(`{${normalizedString}}`);
+            const items = JSON.parse(`{${normalizedString}}`);
+
+            return {
+                success: true,
+                config: items
+            };
         } catch (ex) {
             debug("Manual parsing failed.");
 
@@ -124,11 +126,6 @@ module.exports = class ConfigCommentParser {
             };
 
         }
-
-        return {
-            success: true,
-            config: items
-        };
     }
 
     /**

package/lib/linter/index.js

@@ -1,13 +1,11 @@
 "use strict";
 
 const { Linter } = require("./linter");
-const interpolate = require("./interpolate");
 const SourceCodeFixer = require("./source-code-fixer");
 
 module.exports = {
     Linter,
 
     // For testers.
-    SourceCodeFixer,
-    interpolate
+    SourceCodeFixer
 };

package/lib/linter/interpolate.js

@@ -9,13 +9,30 @@
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = (text, data) => {
+/**
+ * Returns a global expression matching placeholders in messages.
+ * @returns {RegExp} Global regular expression matching placeholders
+ */
+function getPlaceholderMatcher() {
+    return /\{\{([^{}]+?)\}\}/gu;
+}
+
+/**
+ * Replaces {{ placeholders }} in the message with the provided data.
+ * Does not replace placeholders not available in the data.
+ * @param {string} text Original message with potential placeholders
+ * @param {Record<string, string>} data Map of placeholder name to its value
+ * @returns {string} Message with replaced placeholders
+ */
+function interpolate(text, data) {
     if (!data) {
         return text;
     }
 
+    const matcher = getPlaceholderMatcher();
+
     // Substitution content for any {{ }} markers.
-    return text.replace(/\{\{([^{}]+?)\}\}/gu, (fullMatch, termWithWhitespace) => {
+    return text.replace(matcher, (fullMatch, termWithWhitespace) => {
         const term = termWithWhitespace.trim();
 
         if (term in data) {
@@ -25,4 +42,9 @@ module.exports = (text, data) => {
         // Preserve old behavior: If parameter name not provided, don't replace it.
         return fullMatch;
     });
+}
+
+module.exports = {
+    getPlaceholderMatcher,
+    interpolate
 };