eslint 9.0.0-alpha.1 → 9.0.0-alpha.2

package/README.md

@@ -117,7 +117,7 @@ Yes, ESLint natively supports parsing JSX syntax (this must be enabled in [confi
 
 ### What ECMAScript versions does ESLint support?
 
-ESLint has full support for ECMAScript 3, 5 (default), 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, and 2023. You can set your desired ECMAScript syntax (and other settings, like global variables or your target environments) through [configuration](https://eslint.org/docs/latest/use/configure).
+ESLint has full support for ECMAScript 3, 5, and every year from 2015 up until the most recent stage 4 specification (the default). You can set your desired ECMAScript syntax and other settings (like global variables) through [configuration](https://eslint.org/docs/latest/use/configure).
 
 ### What about experimental features?
 

package/lib/eslint/eslint.js

@@ -613,6 +613,13 @@ class ESLint {
             });
         }
 
+        // Check for the .eslintignore file, and warn if it's present.
+        if (existsSync(path.resolve(processedOptions.cwd, ".eslintignore"))) {
+            process.emitWarning(
+                "The \".eslintignore\" file is no longer supported. Switch to using the \"ignores\" property in \"eslint.config.js\": https://eslint.org/docs/latest/use/configure/migration-guide#ignoring-files",
+                "ESLintIgnoreWarning"
+            );
+        }
     }
 
     /**

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

@@ -177,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;
@@ -193,11 +193,7 @@ class CodePath {
              * @returns {void}
              */
             skip() {
-                if (stack.length <= 1) {
-                    broken = true;
-                } else {
-                    skippedSegment = stack.at(-2)[0];
-                }
+                skipped.add(segment);
             },
 
             /**
@@ -222,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) {
 
@@ -258,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
@@ -284,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/rule-tester/rule-tester.js

@@ -13,10 +13,12 @@
 const
     assert = require("assert"),
     util = require("util"),
+    path = require("path"),
     equal = require("fast-deep-equal"),
     Traverser = require("../shared/traverser"),
     { getRuleOptionsSchema } = require("../config/flat-config-helpers"),
-    { Linter, SourceCodeFixer, interpolate } = require("../linter");
+    { Linter, SourceCodeFixer, interpolate } = require("../linter"),
+    stringify = require("json-stable-stringify-without-jsonify");
 
 const { FlatConfigArray } = require("../config/flat-config-array");
 const { defaultConfig } = require("../config/default-config");
@@ -26,6 +28,7 @@ const ajv = require("../shared/ajv")({ strictDefaults: true });
 const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 const { SourceCode } = require("../source-code");
 const { ConfigArraySymbol } = require("@humanwhocodes/config-array");
+const { isSerializable } = require("../shared/serialization");
 
 //------------------------------------------------------------------------------
 // Typedefs
@@ -499,6 +502,9 @@ class RuleTester {
             linter = this.linter,
             ruleId = `rule-to-test/${ruleName}`;
 
+        const seenValidTestCases = new Set();
+        const seenInvalidTestCases = new Set();
+
         if (!rule || typeof rule !== "object" || typeof rule.create !== "function") {
             throw new TypeError("Rule must be an object with a `create` method");
         }
@@ -577,7 +583,15 @@ class RuleTester {
          * @private
          */
         function runRuleForItem(item) {
-            const configs = new FlatConfigArray(testerConfig, { baseConfig });
+            const flatConfigArrayOptions = {
+                baseConfig
+            };
+
+            if (item.filename) {
+                flatConfigArrayOptions.basePath = path.parse(item.filename).root;
+            }
+
+            const configs = new FlatConfigArray(testerConfig, flatConfigArrayOptions);
 
             /*
              * Modify the returned config so that the parser is wrapped to catch
@@ -794,6 +808,32 @@ class RuleTester {
             }
         }
 
+        /**
+         * Check if this test case is a duplicate of one we have seen before.
+         * @param {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
+         */
+        function checkDuplicateTestCase(item, seenTestCases) {
+            if (!isSerializable(item)) {
+
+                /*
+                 * If we can't serialize a test case (because it contains a function, RegExp, etc), skip the check.
+                 * This might happen with properties like: options, plugins, settings, languageOptions.parser, languageOptions.parserOptions.
+                 */
+                return;
+            }
+
+            const serializedTestCase = stringify(item);
+
+            assert(
+                !seenTestCases.has(serializedTestCase),
+                "detected duplicate test case"
+            );
+            seenTestCases.add(serializedTestCase);
+        }
+
         /**
          * Check if the template is valid or not
          * all valid cases go through this
@@ -809,6 +849,8 @@ class RuleTester {
                 assert.ok(typeof item.name === "string", "Optional test case property 'name' must be a string");
             }
 
+            checkDuplicateTestCase(item, seenValidTestCases);
+
             const result = runRuleForItem(item);
             const messages = result.messages;
 
@@ -860,6 +902,8 @@ class RuleTester {
                 assert.fail("Invalid cases must have at least one error");
             }
 
+            checkDuplicateTestCase(item, seenInvalidTestCases);
+
             const ruleHasMetaMessages = hasOwnProperty(rule, "meta") && hasOwnProperty(rule.meta, "messages");
             const friendlyIDList = ruleHasMetaMessages ? `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(", ")}]` : null;
 

package/lib/rules/no-implicit-coercion.js

@@ -188,6 +188,7 @@ function getNonEmptyOperand(node) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        hasSuggestions: true,
         type: "suggestion",
 
         docs: {
@@ -229,7 +230,8 @@ module.exports = {
         }],
 
         messages: {
-            useRecommendation: "use `{{recommendation}}` instead."
+            implicitCoercion: "Unexpected implicit coercion encountered. Use `{{recommendation}}` instead.",
+            useRecommendation: "Use `{{recommendation}}` instead."
         }
     },
 
@@ -241,32 +243,54 @@ module.exports = {
          * Reports an error and autofixes the node
          * @param {ASTNode} node An ast node to report the error on.
          * @param {string} recommendation The recommended code for the issue
+         * @param {bool} shouldSuggest Whether this report should offer a suggestion
          * @param {bool} shouldFix Whether this report should fix the node
          * @returns {void}
          */
-        function report(node, recommendation, shouldFix) {
+        function report(node, recommendation, shouldSuggest, shouldFix) {
+
+            /**
+             * Fix function
+             * @param {RuleFixer} fixer The fixer to fix.
+             * @returns {Fix} The fix object.
+             */
+            function fix(fixer) {
+                const tokenBefore = sourceCode.getTokenBefore(node);
+
+                if (
+                    tokenBefore?.range[1] === node.range[0] &&
+                    !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
+                ) {
+                    return fixer.replaceText(node, ` ${recommendation}`);
+                }
+
+                return fixer.replaceText(node, recommendation);
+            }
+
             context.report({
                 node,
-                messageId: "useRecommendation",
-                data: {
-                    recommendation
-                },
+                messageId: "implicitCoercion",
+                data: { recommendation },
                 fix(fixer) {
                     if (!shouldFix) {
                         return null;
                     }
 
-                    const tokenBefore = sourceCode.getTokenBefore(node);
-
-                    if (
-                        tokenBefore &&
-                        tokenBefore.range[1] === node.range[0] &&
-                        !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
-                    ) {
-                        return fixer.replaceText(node, ` ${recommendation}`);
+                    return fix(fixer);
+                },
+                suggest: [
+                    {
+                        messageId: "useRecommendation",
+                        data: { recommendation },
+                        fix(fixer) {
+                            if (shouldFix || !shouldSuggest) {
+                                return null;
+                            }
+
+                            return fix(fixer);
+                        }
                     }
-                    return fixer.replaceText(node, recommendation);
-                }
+                ]
             });
         }
 
@@ -278,8 +302,10 @@ module.exports = {
                 operatorAllowed = options.allow.includes("!!");
                 if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
                     const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
+                    const variable = astUtils.getVariableByName(sourceCode.getScope(node), "Boolean");
+                    const booleanExists = variable?.identifiers.length === 0;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, booleanExists);
                 }
 
                 // ~foo.indexOf(bar)
@@ -290,7 +316,7 @@ module.exports = {
                     const comparison = node.argument.type === "ChainExpression" ? ">= 0" : "!== -1";
                     const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`;
 
-                    report(node, recommendation, false);
+                    report(node, recommendation, false, false);
                 }
 
                 // +foo
@@ -298,7 +324,7 @@ module.exports = {
                 if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
                     const recommendation = `Number(${sourceCode.getText(node.argument)})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
 
                 // -(-foo)
@@ -306,7 +332,7 @@ module.exports = {
                 if (!operatorAllowed && options.number && node.operator === "-" && node.argument.type === "UnaryExpression" && node.argument.operator === "-" && !isNumeric(node.argument.argument)) {
                     const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
 
-                    report(node, recommendation, false);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -322,7 +348,7 @@ module.exports = {
                 if (nonNumericOperand) {
                     const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
 
                 // foo - 0
@@ -330,7 +356,7 @@ module.exports = {
                 if (!operatorAllowed && options.number && node.operator === "-" && node.right.type === "Literal" && node.right.value === 0 && !isNumeric(node.left)) {
                     const recommendation = `Number(${sourceCode.getText(node.left)})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
 
                 // "" + foo
@@ -338,7 +364,7 @@ module.exports = {
                 if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
                     const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -351,7 +377,7 @@ module.exports = {
                     const code = sourceCode.getText(getNonEmptyOperand(node));
                     const recommendation = `${code} = String(${code})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -389,7 +415,7 @@ module.exports = {
                 const code = sourceCode.getText(node.expressions[0]);
                 const recommendation = `String(${code})`;
 
-                report(node, recommendation, true);
+                report(node, recommendation, true, false);
             }
         };
     }

package/lib/rules/no-restricted-imports.js

@@ -161,17 +161,25 @@ module.exports = {
             (Object.hasOwn(options[0], "paths") || Object.hasOwn(options[0], "patterns"));
 
         const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
-        const restrictedPathMessages = restrictedPaths.reduce((memo, importSource) => {
+        const groupedRestrictedPaths = restrictedPaths.reduce((memo, importSource) => {
+            const path = typeof importSource === "string"
+                ? importSource
+                : importSource.name;
+
+            if (!memo[path]) {
+                memo[path] = [];
+            }
+
             if (typeof importSource === "string") {
-                memo[importSource] = { message: null };
+                memo[path].push({});
             } else {
-                memo[importSource.name] = {
+                memo[path].push({
                     message: importSource.message,
                     importNames: importSource.importNames
-                };
+                });
             }
             return memo;
-        }, {});
+        }, Object.create(null));
 
         // Handle patterns too, either as strings or groups
         let restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
@@ -203,57 +211,59 @@ module.exports = {
          * @private
          */
         function checkRestrictedPathAndReport(importSource, importNames, node) {
-            if (!Object.hasOwn(restrictedPathMessages, importSource)) {
+            if (!Object.hasOwn(groupedRestrictedPaths, importSource)) {
                 return;
             }
 
-            const customMessage = restrictedPathMessages[importSource].message;
-            const restrictedImportNames = restrictedPathMessages[importSource].importNames;
+            groupedRestrictedPaths[importSource].forEach(restrictedPathEntry => {
+                const customMessage = restrictedPathEntry.message;
+                const restrictedImportNames = restrictedPathEntry.importNames;
 
-            if (restrictedImportNames) {
-                if (importNames.has("*")) {
-                    const specifierData = importNames.get("*")[0];
+                if (restrictedImportNames) {
+                    if (importNames.has("*")) {
+                        const specifierData = importNames.get("*")[0];
+
+                        context.report({
+                            node,
+                            messageId: customMessage ? "everythingWithCustomMessage" : "everything",
+                            loc: specifierData.loc,
+                            data: {
+                                importSource,
+                                importNames: restrictedImportNames,
+                                customMessage
+                            }
+                        });
+                    }
 
+                    restrictedImportNames.forEach(importName => {
+                        if (importNames.has(importName)) {
+                            const specifiers = importNames.get(importName);
+
+                            specifiers.forEach(specifier => {
+                                context.report({
+                                    node,
+                                    messageId: customMessage ? "importNameWithCustomMessage" : "importName",
+                                    loc: specifier.loc,
+                                    data: {
+                                        importSource,
+                                        customMessage,
+                                        importName
+                                    }
+                                });
+                            });
+                        }
+                    });
+                } else {
                     context.report({
                         node,
-                        messageId: customMessage ? "everythingWithCustomMessage" : "everything",
-                        loc: specifierData.loc,
+                        messageId: customMessage ? "pathWithCustomMessage" : "path",
                         data: {
                             importSource,
-                            importNames: restrictedImportNames,
                             customMessage
                         }
                     });
                 }
-
-                restrictedImportNames.forEach(importName => {
-                    if (importNames.has(importName)) {
-                        const specifiers = importNames.get(importName);
-
-                        specifiers.forEach(specifier => {
-                            context.report({
-                                node,
-                                messageId: customMessage ? "importNameWithCustomMessage" : "importName",
-                                loc: specifier.loc,
-                                data: {
-                                    importSource,
-                                    customMessage,
-                                    importName
-                                }
-                            });
-                        });
-                    }
-                });
-            } else {
-                context.report({
-                    node,
-                    messageId: customMessage ? "pathWithCustomMessage" : "path",
-                    data: {
-                        importSource,
-                        customMessage
-                    }
-                });
-            }
+            });
         }
 
         /**

package/lib/rules/no-this-before-super.js

@@ -197,11 +197,26 @@ module.exports = {
                     return;
                 }
 
+                /**
+                 * A collection of nodes to avoid duplicate reports.
+                 * @type {Set<ASTNode>}
+                 */
+                const reported = new Set();
+
                 codePath.traverseSegments((segment, controller) => {
                     const info = segInfoMap[segment.id];
+                    const invalidNodes = info.invalidNodes
+                        .filter(
+
+                            /*
+                             * Avoid duplicate reports.
+                             * When there is a `finally`, invalidNodes may contain already reported node.
+                             */
+                            node => !reported.has(node)
+                        );
 
-                    for (let i = 0; i < info.invalidNodes.length; ++i) {
-                        const invalidNode = info.invalidNodes[i];
+                    for (const invalidNode of invalidNodes) {
+                        reported.add(invalidNode);
 
                         context.report({
                             messageId: "noBeforeSuper",
@@ -273,14 +288,12 @@ module.exports = {
                         const info = segInfoMap[segment.id];
 
                         if (info.superCalled) {
-                            info.invalidNodes = [];
                             controller.skip();
                         } else if (
                             segment.prevSegments.length > 0 &&
                             segment.prevSegments.every(isCalled)
                         ) {
                             info.superCalled = true;
-                            info.invalidNodes = [];
                         }
                     }
                 );

package/lib/shared/serialization.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Serialization utils.
+ * @author Bryan Mishkin
+ */
+
+"use strict";
+
+/**
+ * Check if a value is a primitive or plain object created by the Object constructor.
+ * @param {any} val the value to check
+ * @returns {boolean} true if so
+ * @private
+ */
+function isSerializablePrimitiveOrPlainObject(val) {
+    return (
+        val === null ||
+        typeof val === "string" ||
+         typeof val === "boolean" ||
+         typeof val === "number" ||
+         (typeof val === "object" && val.constructor === Object) ||
+         Array.isArray(val)
+    );
+}
+
+/**
+ * Check if a value is serializable.
+ * Functions or objects like RegExp cannot be serialized by JSON.stringify().
+ * Inspired by: https://stackoverflow.com/questions/30579940/reliable-way-to-check-if-objects-is-serializable-in-javascript
+ * @param {any} val the value
+ * @returns {boolean} true if the value is serializable
+ */
+function isSerializable(val) {
+    if (!isSerializablePrimitiveOrPlainObject(val)) {
+        return false;
+    }
+    if (typeof val === "object") {
+        for (const property in val) {
+            if (Object.hasOwn(val, property)) {
+                if (!isSerializablePrimitiveOrPlainObject(val[property])) {
+                    return false;
+                }
+                if (typeof val[property] === "object") {
+                    if (!isSerializable(val[property])) {
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    return true;
+}
+
+module.exports = {
+    isSerializable
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.0.0-alpha.1",
+  "version": "9.0.0-alpha.2",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -66,7 +66,7 @@
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.6.1",
     "@eslint/eslintrc": "^3.0.0",
-    "@eslint/js": "9.0.0-alpha.0",
+    "@eslint/js": "9.0.0-alpha.2",
     "@humanwhocodes/config-array": "^0.11.14",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
@@ -77,7 +77,7 @@
     "escape-string-regexp": "^4.0.0",
     "eslint-scope": "^8.0.0",
     "eslint-visitor-keys": "^3.4.3",
-    "espree": "^9.6.1",
+    "espree": "^10.0.0",
     "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
@@ -135,7 +135,7 @@
     "load-perf": "^0.2.0",
     "markdown-it": "^12.2.0",
     "markdown-it-container": "^3.0.0",
-    "markdownlint": "^0.32.0",
+    "markdownlint": "^0.33.0",
     "markdownlint-cli": "^0.38.0",
     "marked": "^4.0.8",
     "memfs": "^3.0.1",