eslint 8.47.0 → 8.57.0

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

@@ -30,7 +30,7 @@ function compareLocations(itemA, itemB) {
 
 /**
  * Groups a set of directives into sub-arrays by their parent comment.
- * @param {Directive[]} directives Unused directives to be removed.
+ * @param {Iterable<Directive>} directives Unused directives to be removed.
  * @returns {Directive[][]} Directives grouped by their parent comment.
  */
 function groupByParentComment(directives) {
@@ -87,7 +87,7 @@ function createIndividualDirectivesRemoval(directives, commentToken) {
     return directives.map(directive => {
         const { ruleId } = directive;
 
-        const regex = new RegExp(String.raw`(?:^|\s*,\s*)${escapeRegExp(ruleId)}(?:\s*,\s*|$)`, "u");
+        const regex = new RegExp(String.raw`(?:^|\s*,\s*)(?<quote>['"]?)${escapeRegExp(ruleId)}\k<quote>(?:\s*,\s*|$)`, "u");
         const match = regex.exec(listText);
         const matchedText = match[0];
         const matchStartOffset = listStartOffset + match.index;
@@ -177,10 +177,10 @@ function createCommentRemoval(directives, commentToken) {
 
 /**
  * Parses details from directives to create output Problems.
- * @param {Directive[]} allDirectives Unused directives to be removed.
+ * @param {Iterable<Directive>} allDirectives Unused directives to be removed.
  * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems.
  */
-function processUnusedDisableDirectives(allDirectives) {
+function processUnusedDirectives(allDirectives) {
     const directiveGroups = groupByParentComment(allDirectives);
 
     return directiveGroups.flatMap(
@@ -199,6 +199,95 @@ function processUnusedDisableDirectives(allDirectives) {
     );
 }
 
+/**
+ * Collect eslint-enable comments that are removing suppressions by eslint-disable comments.
+ * @param {Directive[]} directives The directives to check.
+ * @returns {Set<Directive>} The used eslint-enable comments
+ */
+function collectUsedEnableDirectives(directives) {
+
+    /**
+     * A Map of `eslint-enable` keyed by ruleIds that may be marked as used.
+     * If `eslint-enable` does not have a ruleId, the key will be `null`.
+     * @type {Map<string|null, Directive>}
+     */
+    const enabledRules = new Map();
+
+    /**
+     * A Set of `eslint-enable` marked as used.
+     * It is also the return value of `collectUsedEnableDirectives` function.
+     * @type {Set<Directive>}
+     */
+    const usedEnableDirectives = new Set();
+
+    /*
+     * Checks the directives backwards to see if the encountered `eslint-enable` is used by the previous `eslint-disable`,
+     * and if so, stores the `eslint-enable` in `usedEnableDirectives`.
+     */
+    for (let index = directives.length - 1; index >= 0; index--) {
+        const directive = directives[index];
+
+        if (directive.type === "disable") {
+            if (enabledRules.size === 0) {
+                continue;
+            }
+            if (directive.ruleId === null) {
+
+                // If encounter `eslint-disable` without ruleId,
+                // mark all `eslint-enable` currently held in enabledRules as used.
+                // e.g.
+                //    /* eslint-disable */ <- current directive
+                //    /* eslint-enable rule-id1 */ <- used
+                //    /* eslint-enable rule-id2 */ <- used
+                //    /* eslint-enable */ <- used
+                for (const enableDirective of enabledRules.values()) {
+                    usedEnableDirectives.add(enableDirective);
+                }
+                enabledRules.clear();
+            } else {
+                const enableDirective = enabledRules.get(directive.ruleId);
+
+                if (enableDirective) {
+
+                    // If encounter `eslint-disable` with ruleId, and there is an `eslint-enable` with the same ruleId in enabledRules,
+                    // mark `eslint-enable` with ruleId as used.
+                    // e.g.
+                    //    /* eslint-disable rule-id */ <- current directive
+                    //    /* eslint-enable rule-id */ <- used
+                    usedEnableDirectives.add(enableDirective);
+                } else {
+                    const enabledDirectiveWithoutRuleId = enabledRules.get(null);
+
+                    if (enabledDirectiveWithoutRuleId) {
+
+                        // If encounter `eslint-disable` with ruleId, and there is no `eslint-enable` with the same ruleId in enabledRules,
+                        // mark `eslint-enable` without ruleId as used.
+                        // e.g.
+                        //    /* eslint-disable rule-id */ <- current directive
+                        //    /* eslint-enable */ <- used
+                        usedEnableDirectives.add(enabledDirectiveWithoutRuleId);
+                    }
+                }
+            }
+        } else if (directive.type === "enable") {
+            if (directive.ruleId === null) {
+
+                // If encounter `eslint-enable` without ruleId, the `eslint-enable` that follows it are unused.
+                // So clear enabledRules.
+                // e.g.
+                //    /* eslint-enable */ <- current directive
+                //    /* eslint-enable rule-id *// <- unused
+                //    /* eslint-enable */ <- unused
+                enabledRules.clear();
+                enabledRules.set(null, directive);
+            } else {
+                enabledRules.set(directive.ruleId, directive);
+            }
+        }
+    }
+    return usedEnableDirectives;
+}
+
 /**
  * This is the same as the exported function, except that it
  * doesn't handle disable-line and disable-next-line directives, and it always reports unused
@@ -206,7 +295,7 @@ function processUnusedDisableDirectives(allDirectives) {
  * @param {Object} options options for applying directives. This is the same as the options
  * for the exported function, except that `reportUnusedDisableDirectives` is not supported
  * (this function always reports unused disable directives).
- * @returns {{problems: LintMessage[], unusedDisableDirectives: LintMessage[]}} An object with a list
+ * @returns {{problems: LintMessage[], unusedDirectives: LintMessage[]}} An object with a list
  * of problems (including suppressed ones) and unused eslint-disable directives
  */
 function applyDirectives(options) {
@@ -258,17 +347,42 @@ function applyDirectives(options) {
     const unusedDisableDirectivesToReport = options.directives
         .filter(directive => directive.type === "disable" && !usedDisableDirectives.has(directive));
 
-    const processed = processUnusedDisableDirectives(unusedDisableDirectivesToReport);
 
-    const unusedDisableDirectives = processed
+    const unusedEnableDirectivesToReport = new Set(
+        options.directives.filter(directive => directive.unprocessedDirective.type === "enable")
+    );
+
+    /*
+     * If directives has the eslint-enable directive,
+     * check whether the eslint-enable comment is used.
+     */
+    if (unusedEnableDirectivesToReport.size > 0) {
+        for (const directive of collectUsedEnableDirectives(options.directives)) {
+            unusedEnableDirectivesToReport.delete(directive);
+        }
+    }
+
+    const processed = processUnusedDirectives(unusedDisableDirectivesToReport)
+        .concat(processUnusedDirectives(unusedEnableDirectivesToReport));
+
+    const unusedDirectives = processed
         .map(({ description, fix, unprocessedDirective }) => {
             const { parentComment, type, line, column } = unprocessedDirective;
 
+            let message;
+
+            if (type === "enable") {
+                message = description
+                    ? `Unused eslint-enable directive (no matching eslint-disable directives were found for ${description}).`
+                    : "Unused eslint-enable directive (no matching eslint-disable directives were found).";
+            } else {
+                message = description
+                    ? `Unused eslint-disable directive (no problems were reported from ${description}).`
+                    : "Unused eslint-disable directive (no problems were reported).";
+            }
             return {
                 ruleId: null,
-                message: description
-                    ? `Unused eslint-disable directive (no problems were reported from ${description}).`
-                    : "Unused eslint-disable directive (no problems were reported).",
+                message,
                 line: type === "disable-next-line" ? parentComment.commentToken.loc.start.line : line,
                 column: type === "disable-next-line" ? parentComment.commentToken.loc.start.column + 1 : column,
                 severity: options.reportUnusedDisableDirectives === "warn" ? 1 : 2,
@@ -277,7 +391,7 @@ function applyDirectives(options) {
             };
         });
 
-    return { problems, unusedDisableDirectives };
+    return { problems, unusedDirectives };
 }
 
 /**
@@ -344,8 +458,8 @@ module.exports = ({ directives, disableFixes, problems, reportUnusedDisableDirec
 
     return reportUnusedDisableDirectives !== "off"
         ? lineDirectivesResult.problems
-            .concat(blockDirectivesResult.unusedDisableDirectives)
-            .concat(lineDirectivesResult.unusedDisableDirectives)
+            .concat(blockDirectivesResult.unusedDirectives)
+            .concat(lineDirectivesResult.unusedDirectives)
             .sort(compareLocations)
         : lineDirectivesResult.problems;
 };

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

@@ -192,15 +192,18 @@ function forwardCurrentToHead(analyzer, node) {
         headSegment = headSegments[i];
 
         if (currentSegment !== headSegment && currentSegment) {
-            debug.dump(`onCodePathSegmentEnd ${currentSegment.id}`);
 
-            if (currentSegment.reachable) {
-                analyzer.emitter.emit(
-                    "onCodePathSegmentEnd",
-                    currentSegment,
-                    node
-                );
-            }
+            const eventName = currentSegment.reachable
+                ? "onCodePathSegmentEnd"
+                : "onUnreachableCodePathSegmentEnd";
+
+            debug.dump(`${eventName} ${currentSegment.id}`);
+
+            analyzer.emitter.emit(
+                eventName,
+                currentSegment,
+                node
+            );
         }
     }
 
@@ -213,16 +216,19 @@ function forwardCurrentToHead(analyzer, node) {
         headSegment = headSegments[i];
 
         if (currentSegment !== headSegment && headSegment) {
-            debug.dump(`onCodePathSegmentStart ${headSegment.id}`);
+
+            const eventName = headSegment.reachable
+                ? "onCodePathSegmentStart"
+                : "onUnreachableCodePathSegmentStart";
+
+            debug.dump(`${eventName} ${headSegment.id}`);
 
             CodePathSegment.markUsed(headSegment);
-            if (headSegment.reachable) {
-                analyzer.emitter.emit(
-                    "onCodePathSegmentStart",
-                    headSegment,
-                    node
-                );
-            }
+            analyzer.emitter.emit(
+                eventName,
+                headSegment,
+                node
+            );
         }
     }
 
@@ -241,15 +247,17 @@ function leaveFromCurrentSegment(analyzer, node) {
 
     for (let i = 0; i < currentSegments.length; ++i) {
         const currentSegment = currentSegments[i];
+        const eventName = currentSegment.reachable
+            ? "onCodePathSegmentEnd"
+            : "onUnreachableCodePathSegmentEnd";
 
-        debug.dump(`onCodePathSegmentEnd ${currentSegment.id}`);
-        if (currentSegment.reachable) {
-            analyzer.emitter.emit(
-                "onCodePathSegmentEnd",
-                currentSegment,
-                node
-            );
-        }
+        debug.dump(`${eventName} ${currentSegment.id}`);
+
+        analyzer.emitter.emit(
+            eventName,
+            currentSegment,
+            node
+        );
     }
 
     state.currentSegments = [];

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

@@ -1,5 +1,5 @@
 /**
- * @fileoverview A class of the code path segment.
+ * @fileoverview The CodePathSegment class.
  * @author Toru Nagashima
  */
 
@@ -30,10 +30,22 @@ function isReachable(segment) {
 
 /**
  * A code path segment.
+ *
+ * Each segment is arranged in a series of linked lists (implemented by arrays)
+ * that keep track of the previous and next segments in a code path. In this way,
+ * you can navigate between all segments in any code path so long as you have a
+ * reference to any segment in that code path.
+ *
+ * When first created, the segment is in a detached state, meaning that it knows the
+ * segments that came before it but those segments don't know that this new segment
+ * follows it. Only when `CodePathSegment#markUsed()` is called on a segment does it
+ * officially become part of the code path by updating the previous segments to know
+ * that this new segment follows.
  */
 class CodePathSegment {
 
     /**
+     * Creates a new instance.
      * @param {string} id An identifier.
      * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.
      *   This array includes unreachable segments.
@@ -49,27 +61,25 @@ class CodePathSegment {
         this.id = id;
 
         /**
-         * An array of the next segments.
+         * An array of the next reachable segments.
          * @type {CodePathSegment[]}
          */
         this.nextSegments = [];
 
         /**
-         * An array of the previous segments.
+         * An array of the previous reachable segments.
          * @type {CodePathSegment[]}
          */
         this.prevSegments = allPrevSegments.filter(isReachable);
 
         /**
-         * An array of the next segments.
-         * This array includes unreachable segments.
+         * An array of all next segments including reachable and unreachable.
          * @type {CodePathSegment[]}
          */
         this.allNextSegments = [];
 
         /**
-         * An array of the previous segments.
-         * This array includes unreachable segments.
+         * An array of all previous segments including reachable and unreachable.
          * @type {CodePathSegment[]}
          */
         this.allPrevSegments = allPrevSegments;
@@ -83,7 +93,11 @@ class CodePathSegment {
         // Internal data.
         Object.defineProperty(this, "internal", {
             value: {
+
+                // determines if the segment has been attached to the code path
                 used: false,
+
+                // array of previous segments coming from the end of a loop
                 loopedPrevSegments: []
             }
         });
@@ -113,9 +127,10 @@ class CodePathSegment {
     }
 
     /**
-     * Creates a segment that follows given segments.
+     * Creates a new segment and appends it after the given segments.
      * @param {string} id An identifier.
-     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.
+     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments
+     *      to append to.
      * @returns {CodePathSegment} The created segment.
      */
     static newNext(id, allPrevSegments) {
@@ -127,7 +142,7 @@ class CodePathSegment {
     }
 
     /**
-     * Creates an unreachable segment that follows given segments.
+     * Creates an unreachable segment and appends it after the given segments.
      * @param {string} id An identifier.
      * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.
      * @returns {CodePathSegment} The created segment.
@@ -137,7 +152,7 @@ class CodePathSegment {
 
         /*
          * In `if (a) return a; foo();` case, the unreachable segment preceded by
-         * the return statement is not used but must not be remove.
+         * the return statement is not used but must not be removed.
          */
         CodePathSegment.markUsed(segment);
 
@@ -157,7 +172,7 @@ class CodePathSegment {
     }
 
     /**
-     * Makes a given segment being used.
+     * Marks a given segment as used.
      *
      * And this function registers the segment into the previous segments as a next.
      * @param {CodePathSegment} segment A segment to mark.
@@ -172,6 +187,13 @@ class CodePathSegment {
         let i;
 
         if (segment.reachable) {
+
+            /*
+             * If the segment is reachable, then it's officially part of the
+             * code path. This loops through all previous segments to update
+             * their list of next segments. Because the segment is reachable,
+             * it's added to both `nextSegments` and `allNextSegments`.
+             */
             for (i = 0; i < segment.allPrevSegments.length; ++i) {
                 const prevSegment = segment.allPrevSegments[i];
 
@@ -179,6 +201,13 @@ class CodePathSegment {
                 prevSegment.nextSegments.push(segment);
             }
         } else {
+
+            /*
+             * If the segment is not reachable, then it's not officially part of the
+             * code path. This loops through all previous segments to update
+             * their list of next segments. Because the segment is not reachable,
+             * it's added only to `allNextSegments`.
+             */
             for (i = 0; i < segment.allPrevSegments.length; ++i) {
                 segment.allPrevSegments[i].allNextSegments.push(segment);
             }
@@ -196,19 +225,20 @@ class CodePathSegment {
     }
 
     /**
-     * Replaces unused segments with the previous segments of each unused segment.
-     * @param {CodePathSegment[]} segments An array of segments to replace.
-     * @returns {CodePathSegment[]} The replaced array.
+     * Creates a new array based on an array of segments. If any segment in the
+     * array is unused, then it is replaced by all of its previous segments.
+     * All used segments are returned as-is without replacement.
+     * @param {CodePathSegment[]} segments The array of segments to flatten.
+     * @returns {CodePathSegment[]} The flattened array.
      */
     static flattenUnusedSegments(segments) {
-        const done = Object.create(null);
-        const retv = [];
+        const done = new Set();
 
         for (let i = 0; i < segments.length; ++i) {
             const segment = segments[i];
 
             // Ignores duplicated.
-            if (done[segment.id]) {
+            if (done.has(segment)) {
                 continue;
             }
 
@@ -217,18 +247,16 @@ class CodePathSegment {
                 for (let j = 0; j < segment.allPrevSegments.length; ++j) {
                     const prevSegment = segment.allPrevSegments[j];
 
-                    if (!done[prevSegment.id]) {
-                        done[prevSegment.id] = true;
-                        retv.push(prevSegment);
+                    if (!done.has(prevSegment)) {
+                        done.add(prevSegment);
                     }
                 }
             } else {
-                done[segment.id] = true;
-                retv.push(segment);
+                done.add(segment);
             }
         }
 
-        return retv;
+        return [...done];
     }
 }