eslint 9.0.0-rc.0 → 9.1.0

package/lib/options.js

@@ -38,7 +38,7 @@ const optionator = require("optionator");
  * @property {boolean} [help] Show help
  * @property {boolean} ignore Disable use of ignore files and patterns
  * @property {string} [ignorePath] Specify path of ignore file
- * @property {string[]} [ignorePattern] Pattern of files to ignore (in addition to those in .eslintignore)
+ * @property {string[]} [ignorePattern] Patterns of files to ignore. In eslintrc mode, these are in addition to `.eslintignore`
  * @property {boolean} init Run config initialization wizard
  * @property {boolean} inlineConfig Prevent comments from changing config or rules
  * @property {number} maxWarnings Number of warnings to trigger nonzero exit code
@@ -60,6 +60,7 @@ const optionator = require("optionator");
  * @property {boolean} [passOnNoPatterns=false] When set to true, missing patterns cause
  *      the linting operation to short circuit and not report any failures.
  * @property {string[]} _ Positional filenames or patterns
+ * @property {boolean} [stats] Report additional statistics
  */
 
 //------------------------------------------------------------------------------
@@ -103,6 +104,16 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let inspectConfigFlag;
+
+    if (usingFlatConfig) {
+        inspectConfigFlag = {
+            option: "inspect-config",
+            type: "Boolean",
+            description: "Open the config inspector with the current configuration"
+        };
+    }
+
     let extFlag;
 
     if (!usingFlatConfig) {
@@ -143,6 +154,17 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let statsFlag;
+
+    if (usingFlatConfig) {
+        statsFlag = {
+            option: "stats",
+            type: "Boolean",
+            default: "false",
+            description: "Add statistics to the lint report"
+        };
+    }
+
     let warnIgnoredFlag;
 
     if (usingFlatConfig) {
@@ -173,6 +195,7 @@ module.exports = function(usingFlatConfig) {
                     ? "Use this configuration instead of eslint.config.js, eslint.config.mjs, or eslint.config.cjs"
                     : "Use this configuration, overriding .eslintrc.* config options if present"
             },
+            inspectConfigFlag,
             envFlag,
             extFlag,
             {
@@ -238,7 +261,7 @@ module.exports = function(usingFlatConfig) {
             {
                 option: "ignore-pattern",
                 type: "[String]",
-                description: "Pattern of files to ignore (in addition to those in .eslintignore)",
+                description: `Patterns of files to ignore${usingFlatConfig ? "" : " (in addition to those in .eslintignore)"}`,
                 concatRepeatedArrays: [true, {
                     oneValuePerFlag: true
                 }]
@@ -400,7 +423,8 @@ module.exports = function(usingFlatConfig) {
                 option: "print-config",
                 type: "path::String",
                 description: "Print the configuration for the given file"
-            }
+            },
+            statsFlag
         ].filter(value => !!value)
     });
 };

package/lib/rule-tester/rule-tester.js

@@ -136,6 +136,15 @@ const suggestionObjectParameters = new Set([
 ]);
 const friendlySuggestionObjectParameterList = `[${[...suggestionObjectParameters].map(key => `'${key}'`).join(", ")}]`;
 
+/*
+ * Ignored test case properties when checking for test case duplicates.
+ */
+const duplicationIgnoredParameters = new Set([
+    "name",
+    "errors",
+    "output"
+]);
+
 const forbiddenMethods = [
     "applyInlineConfig",
     "applyLanguageOptions",
@@ -848,7 +857,7 @@ class RuleTester {
 
         /**
          * Check if this test case is a duplicate of one we have seen before.
-         * @param {Object} item test case object
+         * @param {string|Object} item test case object
          * @param {Set<string>} seenTestCases set of serialized test cases we have seen so far (managed by this function)
          * @returns {void}
          * @private
@@ -863,7 +872,14 @@ class RuleTester {
                 return;
             }
 
-            const serializedTestCase = stringify(item);
+            const normalizedItem = typeof item === "string" ? { code: item } : item;
+            const serializedTestCase = stringify(normalizedItem, {
+                replacer(key, value) {
+
+                    // "this" is the currently stringified object --> only ignore top-level properties
+                    return (normalizedItem !== this || !duplicationIgnoredParameters.has(key)) ? value : void 0;
+                }
+            });
 
             assert(
                 !seenTestCases.has(serializedTestCase),

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/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
@@ -165,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."
         }
     },
 
@@ -186,7 +169,7 @@ module.exports = {
         /**
          * @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.
@@ -194,7 +177,7 @@ module.exports = {
          * @returns {boolean} The flag which shows `super()` is called in some paths
          */
         function isCalledInSomePath(segment) {
-            return segment.reachable && segInfoMap[segment.id]?.calledInSomePaths;
+            return segment.reachable && segInfoMap[segment.id].calledInSomePaths;
         }
 
         /**
@@ -212,17 +195,6 @@ module.exports = {
          * @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;
         }
 
@@ -279,9 +251,9 @@ module.exports = {
                 }
 
                 // Reports if `super()` lacked.
-                const seenSegments = codePath.returnedSegments.filter(hasSegmentBeenSeen);
-                const calledInEveryPaths = seenSegments.every(isCalledInEveryPath);
-                const calledInSomePaths = seenSegments.some(isCalledInSomePath);
+                const returnedSegments = codePath.returnedSegments;
+                const calledInEveryPaths = returnedSegments.every(isCalledInEveryPath);
+                const calledInSomePaths = returnedSegments.some(isCalledInSomePath);
 
                 if (!calledInEveryPaths) {
                     context.report({
@@ -296,28 +268,38 @@ 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] = new SegmentInfo();
 
-                // When there are previous segments, aggregates these.
-                const prevSegments = segment.prevSegments;
-
-                if (prevSegments.length > 0) {
-                    const seenPrevSegments = prevSegments.filter(hasSegmentBeenSeen);
+                const seenPrevSegments = segment.prevSegments.filter(hasSegmentBeenSeen);
 
+                // When there are previous segments, aggregates these.
+                if (seenPrevSegments.length > 0) {
                     info.calledInSomePaths = seenPrevSegments.some(isCalledInSomePath);
                     info.calledInEveryPaths = seenPrevSegments.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;
+                }
             },
 
             onUnreachableCodePathSegmentStart(segment) {
@@ -343,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 => {
-                        const info = segInfoMap[segment.id] ?? new SegmentInfo();
+                    (segment, controller) => {
+                        const info = segInfoMap[segment.id];
+
+                        // 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);
 
-                        // Updates flags.
-                        info.calledInSomePaths = seenPrevSegments.some(isCalledInSomePath);
-                        info.calledInEveryPaths = 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 = [];
@@ -375,9 +362,6 @@ module.exports = {
                                 });
                             }
                         }
-
-                        // save just in case we created a new SegmentInfo object
-                        segInfoMap[segment.id] = info;
                     }
                 );
             },
@@ -388,7 +372,7 @@ module.exports = {
              * @returns {void}
              */
             "CallExpression:exit"(node) {
-                if (!(funcInfo && funcInfo.isConstructor)) {
+                if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
 
@@ -398,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
-                    });
                 }
             },
 
@@ -442,7 +419,7 @@ module.exports = {
              * @returns {void}
              */
             ReturnStatement(node) {
-                if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {
+                if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
 
@@ -462,14 +439,6 @@ module.exports = {
                         info.calledInSomePaths = info.calledInEveryPaths = true;
                     }
                 }
-            },
-
-            /**
-             * Resets state.
-             * @returns {void}
-             */
-            "Program:exit"() {
-                segInfoMap = Object.create(null);
             }
         };
     }

package/lib/rules/no-constant-condition.js

@@ -31,8 +31,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     checkLoops: {
-                        type: "boolean",
-                        default: true
+                        enum: ["all", "allExceptWhileTrue", "none", true, false]
                     }
                 },
                 additionalProperties: false
@@ -45,11 +44,17 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {},
-            checkLoops = options.checkLoops !== false,
-            loopSetStack = [];
+        const options = context.options[0] || {};
+        let checkLoops = options.checkLoops ?? "allExceptWhileTrue";
+        const loopSetStack = [];
         const sourceCode = context.sourceCode;
 
+        if (options.checkLoops === true) {
+            checkLoops = "all";
+        } else if (options.checkLoops === false) {
+            checkLoops = "none";
+        }
+
         let loopsInCurrentScope = new Set();
 
         //--------------------------------------------------------------------------
@@ -120,7 +125,7 @@ module.exports = {
          * @private
          */
         function checkLoop(node) {
-            if (checkLoops) {
+            if (checkLoops === "all" || checkLoops === "allExceptWhileTrue") {
                 trackConstantConditionLoop(node);
             }
         }
@@ -132,7 +137,13 @@ module.exports = {
         return {
             ConditionalExpression: reportIfConstant,
             IfStatement: reportIfConstant,
-            WhileStatement: checkLoop,
+            WhileStatement(node) {
+                if (node.test.type === "Literal" && node.test.value === true && checkLoops === "allExceptWhileTrue") {
+                    return;
+                }
+
+                checkLoop(node);
+            },
             "WhileStatement:exit": checkConstantConditionLoopInSet,
             DoWhileStatement: checkLoop,
             "DoWhileStatement:exit": checkConstantConditionLoopInSet,

package/lib/rules/no-lone-blocks.js

@@ -117,7 +117,7 @@ module.exports = {
             };
 
             ruleDef.VariableDeclaration = function(node) {
-                if (node.kind === "let" || node.kind === "const") {
+                if (node.kind !== "var") {
                     markLoneBlock(node);
                 }
             };