eslint 8.56.0 → 9.0.0-alpha.1

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
@@ -166,7 +171,7 @@ function createCommentRemoval(directives, commentToken) {
     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: " "
@@ -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))
     );
 
     /*
@@ -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.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
@@ -210,7 +196,7 @@ class CodePath {
                 if (stack.length <= 1) {
                     broken = true;
                 } else {
-                    skippedSegment = stack[stack.length - 2][0];
+                    skippedSegment = stack.at(-2)[0];
                 }
             },
 
@@ -251,7 +237,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];
 

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
-        };
     }
 
     /**