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

package/README.md

@@ -103,7 +103,7 @@ We are now at or near 100% compatibility with JSCS. If you try ESLint and believ
 
 ### Does Prettier replace ESLint?
 
-No, ESLint and Prettier have diffent jobs: ESLint is a linter (looking for problematic patterns) and Prettier is a code formatter. Using both tools is common, refer to [Prettier's documentation](https://prettier.io/docs/en/install#eslint-and-other-linters) to learn how to configure them to work well with each other.
+No, ESLint and Prettier have different jobs: ESLint is a linter (looking for problematic patterns) and Prettier is a code formatter. Using both tools is common, refer to [Prettier's documentation](https://prettier.io/docs/en/install#eslint-and-other-linters) to learn how to configure them to work well with each other.
 
 ### Why can't ESLint find my plugins?
 
@@ -255,11 +255,6 @@ Josh Goldberg ✨
 Francesco Trotta
 </a>
 </td><td align="center" valign="top" width="11%">
-<a href="https://github.com/ota-meshi">
-<img src="https://github.com/ota-meshi.png?s=75" width="75" height="75" alt="Yosuke Ota's Avatar"><br />
-Yosuke Ota
-</a>
-</td><td align="center" valign="top" width="11%">
 <a href="https://github.com/Tanujkanti4441">
 <img src="https://github.com/Tanujkanti4441.png?s=75" width="75" height="75" alt="Tanuj Kanti's Avatar"><br />
 Tanuj Kanti
@@ -299,7 +294,7 @@ The following companies, organizations, and individuals support ESLint's ongoing
 <p><a href="#"><img src="https://images.opencollective.com/2021-frameworks-fund/logo.png" alt="Chrome Frameworks Fund" height="undefined"></a> <a href="https://automattic.com"><img src="https://images.opencollective.com/automattic/d0ef3e1/logo.png" alt="Automattic" height="undefined"></a></p><h3>Gold Sponsors</h3>
 <p><a href="https://engineering.salesforce.com"><img src="https://images.opencollective.com/salesforce/ca8f997/logo.png" alt="Salesforce" height="96"></a> <a href="https://www.airbnb.com/"><img src="https://images.opencollective.com/airbnb/d327d66/logo.png" alt="Airbnb" height="96"></a></p><h3>Silver Sponsors</h3>
 <p><a href="https://www.jetbrains.com/"><img src="https://images.opencollective.com/jetbrains/eb04ddc/logo.png" alt="JetBrains" height="64"></a> <a href="https://liftoff.io/"><img src="https://images.opencollective.com/liftoff/5c4fa84/logo.png" alt="Liftoff" height="64"></a> <a href="https://americanexpress.io"><img src="https://avatars.githubusercontent.com/u/3853301?v=4" alt="American Express" height="64"></a> <a href="https://www.workleap.com"><img src="https://avatars.githubusercontent.com/u/53535748?u=d1e55d7661d724bf2281c1bfd33cb8f99fe2465f&v=4" alt="Workleap" height="64"></a></p><h3>Bronze Sponsors</h3>
-<p><a href="https://themeisle.com"><img src="https://images.opencollective.com/themeisle/d5592fe/logo.png" alt="ThemeIsle" height="32"></a> <a href="https://www.crosswordsolver.org/anagram-solver/"><img src="https://images.opencollective.com/anagram-solver/2666271/logo.png" alt="Anagram Solver" height="32"></a> <a href="https://icons8.com/"><img src="https://images.opencollective.com/icons8/7fa1641/logo.png" alt="Icons8" height="32"></a> <a href="https://discord.com"><img src="https://images.opencollective.com/discordapp/f9645d9/logo.png" alt="Discord" height="32"></a> <a href="https://transloadit.com/"><img src="https://avatars.githubusercontent.com/u/125754?v=4" alt="Transloadit" height="32"></a> <a href="https://www.ignitionapp.com"><img src="https://avatars.githubusercontent.com/u/5753491?v=4" alt="Ignition" height="32"></a> <a href="https://nx.dev"><img src="https://avatars.githubusercontent.com/u/23692104?v=4" alt="Nx" height="32"></a> <a href="https://herocoders.com"><img src="https://avatars.githubusercontent.com/u/37549774?v=4" alt="HeroCoders" height="32"></a></p>
+<p><a href="https://www.notion.so"><img src="https://images.opencollective.com/notion/bf3b117/logo.png" alt="notion" height="32"></a> <a href="https://themeisle.com"><img src="https://images.opencollective.com/themeisle/d5592fe/logo.png" alt="ThemeIsle" height="32"></a> <a href="https://www.crosswordsolver.org/anagram-solver/"><img src="https://images.opencollective.com/anagram-solver/2666271/logo.png" alt="Anagram Solver" height="32"></a> <a href="https://icons8.com/"><img src="https://images.opencollective.com/icons8/7fa1641/logo.png" alt="Icons8" height="32"></a> <a href="https://discord.com"><img src="https://images.opencollective.com/discordapp/f9645d9/logo.png" alt="Discord" height="32"></a> <a href="https://transloadit.com/"><img src="https://avatars.githubusercontent.com/u/125754?v=4" alt="Transloadit" height="32"></a> <a href="https://www.ignitionapp.com"><img src="https://avatars.githubusercontent.com/u/5753491?v=4" alt="Ignition" height="32"></a> <a href="https://nx.dev"><img src="https://avatars.githubusercontent.com/u/23692104?v=4" alt="Nx" height="32"></a> <a href="https://herocoders.com"><img src="https://avatars.githubusercontent.com/u/37549774?v=4" alt="HeroCoders" height="32"></a> <a href="https://usenextbase.com"><img src="https://avatars.githubusercontent.com/u/145838380?v=4" alt="Nextbase Starter Kit" height="32"></a></p>
 <!--sponsorsend-->
 
 ## Technology Sponsors

package/lib/api.js

@@ -9,17 +9,41 @@
 // Requirements
 //-----------------------------------------------------------------------------
 
-const { ESLint } = require("./eslint/eslint");
+const { ESLint, shouldUseFlatConfig } = require("./eslint/eslint");
+const { LegacyESLint } = require("./eslint/legacy-eslint");
 const { Linter } = require("./linter");
 const { RuleTester } = require("./rule-tester");
 const { SourceCode } = require("./source-code");
 
+//-----------------------------------------------------------------------------
+// Functions
+//-----------------------------------------------------------------------------
+
+/**
+ * Loads the correct ESLint constructor given the options.
+ * @param {Object} [options] The options object
+ * @param {boolean} [options.useFlatConfig] Whether or not to use a flat config
+ * @returns {Promise<ESLint|LegacyESLint>} The ESLint constructor
+ */
+async function loadESLint({ useFlatConfig } = {}) {
+
+    /*
+     * Note: The v8.x version of this function also accepted a `cwd` option, but
+     * it is not used in this implementation so we silently ignore it.
+     */
+
+    const shouldESLintUseFlatConfig = useFlatConfig ?? (await shouldUseFlatConfig());
+
+    return shouldESLintUseFlatConfig ? ESLint : LegacyESLint;
+}
+
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
 
 module.exports = {
     Linter,
+    loadESLint,
     ESLint,
     RuleTester,
     SourceCode

package/lib/eslint/eslint.js

@@ -565,6 +565,12 @@ function createExtraneousResultsError() {
  */
 class ESLint {
 
+    /**
+     * The type of configuration used by this class.
+     * @type {string}
+     */
+    static configType = "flat";
+
     /**
      * Creates a new instance of the main ESLint API.
      * @param {ESLintOptions} options The options for this instance.

package/lib/eslint/legacy-eslint.js

@@ -438,6 +438,12 @@ function compareResultsByFilePath(a, b) {
  */
 class LegacyESLint {
 
+    /**
+     * The type of configuration used by this class.
+     * @type {string}
+     */
+    static configType = "eslintrc";
+
     /**
      * Creates a new instance of the main ESLint API.
      * @param {LegacyESLintOptions} options The options for this instance.

package/lib/linter/index.js

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

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

package/lib/linter/linter.js

@@ -43,7 +43,7 @@ const
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
 const { FlatConfigArray } = require("../config/flat-config-array");
 const { RuleValidator } = require("../config/rule-validator");
-const { assertIsRuleOptions, assertIsRuleSeverity } = require("../config/flat-config-schema");
+const { assertIsRuleSeverity } = require("../config/flat-config-schema");
 const { normalizeSeverityToString } = require("../shared/severity");
 const debug = require("debug")("eslint:linter");
 const MAX_AUTOFIX_PASSES = 10;
@@ -326,10 +326,11 @@ function createDisableDirectives(options) {
  * @param {SourceCode} sourceCode The SourceCode object to get comments from.
  * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules
  * @param {string|null} warnInlineConfig If a string then it should warn directive comments as disabled. The string value is the config name what the setting came from.
+ * @param {ConfigData} config Provided config.
  * @returns {{configuredRules: Object, enabledGlobals: {value:string,comment:Token}[], exportedVariables: Object, problems: LintMessage[], disableDirectives: DisableDirective[]}}
  * A collection of the directive comments that were found, along with any problems that occurred when parsing
  */
-function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
+function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config) {
     const configuredRules = {};
     const enabledGlobals = Object.create(null);
     const exportedVariables = {};
@@ -438,8 +439,50 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                             return;
                         }
 
+                        let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+
+                        /*
+                         * If the rule was already configured, inline rule configuration that
+                         * only has severity should retain options from the config and just override the severity.
+                         *
+                         * Example:
+                         *
+                         *   {
+                         *       rules: {
+                         *           curly: ["error", "multi"]
+                         *       }
+                         *   }
+                         *
+                         *   /* eslint curly: ["warn"] * /
+                         *
+                         *   Results in:
+                         *
+                         *   curly: ["warn", "multi"]
+                         */
+                        if (
+
+                            /*
+                             * If inline config for the rule has only severity
+                             */
+                            ruleOptions.length === 1 &&
+
+                            /*
+                             * And the rule was already configured
+                             */
+                            config.rules && Object.hasOwn(config.rules, name)
+                        ) {
+
+                            /*
+                             * Then use severity from the inline config and options from the provided config
+                             */
+                            ruleOptions = [
+                                ruleOptions[0], // severity from the inline config
+                                ...Array.isArray(config.rules[name]) ? config.rules[name].slice(1) : [] // options from the provided config
+                            ];
+                        }
+
                         try {
-                            validator.validateRuleOptions(rule, name, ruleValue);
+                            validator.validateRuleOptions(rule, name, ruleOptions);
                         } catch (err) {
 
                             /*
@@ -460,7 +503,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                             return;
                         }
 
-                        configuredRules[name] = ruleValue;
+                        configuredRules[name] = ruleOptions;
                     });
                 } else {
                     problems.push(parseResult.error);
@@ -1322,7 +1365,7 @@ class Linter {
 
         const sourceCode = slots.lastSourceCode;
         const commentDirectives = options.allowInlineConfig
-            ? getDirectiveComments(sourceCode, ruleId => getRule(slots, ruleId), options.warnInlineConfig)
+            ? getDirectiveComments(sourceCode, ruleId => getRule(slots, ruleId), options.warnInlineConfig, config)
             : { configuredRules: {}, enabledGlobals: {}, exportedVariables: {}, problems: [], disableDirectives: [] };
 
         // augment global scope with declared global variables
@@ -1332,56 +1375,8 @@ class Linter {
             { exportedVariables: commentDirectives.exportedVariables, enabledGlobals: commentDirectives.enabledGlobals }
         );
 
-        /*
-         * Now we determine the final configurations for rules.
-         * First, let all inline rule configurations override those from the config.
-         * Then, check for a special case: if a rule is configured in both places,
-         * inline rule configuration that only has severity should retain options from
-         * the config and just override the severity.
-         *
-         * Example:
-         *
-         *   {
-         *       rules: {
-         *           curly: ["error", "multi"]
-         *       }
-         *   }
-         *
-         *   /* eslint curly: ["warn"] * /
-         *
-         *   Results in:
-         *
-         *   curly: ["warn", "multi"]
-         */
         const configuredRules = Object.assign({}, config.rules, commentDirectives.configuredRules);
 
-        if (config.rules) {
-            for (const [ruleId, ruleInlineConfig] of Object.entries(commentDirectives.configuredRules)) {
-                if (
-
-                    /*
-                     * If inline config for the rule has only severity
-                     */
-                    (!Array.isArray(ruleInlineConfig) || ruleInlineConfig.length === 1) &&
-
-                    /*
-                     * And provided config for the rule has options
-                     */
-                    Object.hasOwn(config.rules, ruleId) &&
-                    (Array.isArray(config.rules[ruleId]) && config.rules[ruleId].length > 1)
-                ) {
-
-                    /*
-                     * Then use severity from the inline config and options from the provided config
-                     */
-                    configuredRules[ruleId] = [
-                        Array.isArray(ruleInlineConfig) ? ruleInlineConfig[0] : ruleInlineConfig, // severity from the inline config
-                        ...config.rules[ruleId].slice(1) // options from the provided config
-                    ];
-                }
-            }
-        }
-
         let lintingProblems;
 
         try {
@@ -1713,17 +1708,67 @@ class Linter {
 
                         try {
 
-                            const ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+                            let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
 
-                            assertIsRuleOptions(ruleId, ruleValue);
                             assertIsRuleSeverity(ruleId, ruleOptions[0]);
 
-                            ruleValidator.validate({
-                                plugins: config.plugins,
-                                rules: {
-                                    [ruleId]: ruleOptions
+                            /*
+                             * If the rule was already configured, inline rule configuration that
+                             * only has severity should retain options from the config and just override the severity.
+                             *
+                             * Example:
+                             *
+                             *   {
+                             *       rules: {
+                             *           curly: ["error", "multi"]
+                             *       }
+                             *   }
+                             *
+                             *   /* eslint curly: ["warn"] * /
+                             *
+                             *   Results in:
+                             *
+                             *   curly: ["warn", "multi"]
+                             */
+
+                            let shouldValidateOptions = true;
+
+                            if (
+
+                                /*
+                                 * If inline config for the rule has only severity
+                                 */
+                                ruleOptions.length === 1 &&
+
+                                /*
+                                 * And the rule was already configured
+                                 */
+                                config.rules && Object.hasOwn(config.rules, ruleId)
+                            ) {
+
+                                /*
+                                 * Then use severity from the inline config and options from the provided config
+                                 */
+                                ruleOptions = [
+                                    ruleOptions[0], // severity from the inline config
+                                    ...config.rules[ruleId].slice(1) // options from the provided config
+                                ];
+
+                                // if the rule was enabled, the options have already been validated
+                                if (config.rules[ruleId][0] > 0) {
+                                    shouldValidateOptions = false;
                                 }
-                            });
+                            }
+
+                            if (shouldValidateOptions) {
+                                ruleValidator.validate({
+                                    plugins: config.plugins,
+                                    rules: {
+                                        [ruleId]: ruleOptions
+                                    }
+                                });
+                            }
+
                             mergedInlineConfig.rules[ruleId] = ruleOptions;
                         } catch (err) {
 
@@ -1763,58 +1808,8 @@ class Linter {
             )
             : { problems: [], disableDirectives: [] };
 
-        /*
-         * Now we determine the final configurations for rules.
-         * First, let all inline rule configurations override those from the config.
-         * Then, check for a special case: if a rule is configured in both places,
-         * inline rule configuration that only has severity should retain options from
-         * the config and just override the severity.
-         *
-         * Example:
-         *
-         *   {
-         *       rules: {
-         *           curly: ["error", "multi"]
-         *       }
-         *   }
-         *
-         *   /* eslint curly: ["warn"] * /
-         *
-         *   Results in:
-         *
-         *   curly: ["warn", "multi"]
-         *
-         * At this point, all rule configurations are normalized to arrays.
-         */
         const configuredRules = Object.assign({}, config.rules, mergedInlineConfig.rules);
 
-        if (config.rules) {
-            for (const [ruleId, ruleInlineConfig] of Object.entries(mergedInlineConfig.rules)) {
-                if (
-
-                    /*
-                     * If inline config for the rule has only severity
-                     */
-                    ruleInlineConfig.length === 1 &&
-
-                    /*
-                     * And provided config for the rule has options
-                     */
-                    Object.hasOwn(config.rules, ruleId) &&
-                    config.rules[ruleId].length > 1
-                ) {
-
-                    /*
-                     * Then use severity from the inline config and options from the provided config
-                     */
-                    configuredRules[ruleId] = [
-                        ruleInlineConfig[0], // severity from the inline config
-                        ...config.rules[ruleId].slice(1) // options from the provided config
-                    ];
-                }
-            }
-        }
-
         let lintingProblems;
 
         sourceCode.finalize();

package/lib/linter/report-translator.js

@@ -11,7 +11,7 @@
 
 const assert = require("assert");
 const ruleFixer = require("./rule-fixer");
-const interpolate = require("./interpolate");
+const { interpolate } = require("./interpolate");
 
 //------------------------------------------------------------------------------
 // Typedefs

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

@@ -17,7 +17,8 @@ const
     equal = require("fast-deep-equal"),
     Traverser = require("../shared/traverser"),
     { getRuleOptionsSchema } = require("../config/flat-config-helpers"),
-    { Linter, SourceCodeFixer, interpolate } = require("../linter"),
+    { Linter, SourceCodeFixer } = require("../linter"),
+    { interpolate, getPlaceholderMatcher } = require("../linter/interpolate"),
     stringify = require("json-stable-stringify-without-jsonify");
 
 const { FlatConfigArray } = require("../config/flat-config-array");
@@ -304,6 +305,39 @@ function throwForbiddenMethodError(methodName, prototype) {
     };
 }
 
+/**
+ * Extracts names of {{ placeholders }} from the reported message.
+ * @param   {string} message Reported message
+ * @returns {string[]} Array of placeholder names
+ */
+function getMessagePlaceholders(message) {
+    const matcher = getPlaceholderMatcher();
+
+    return Array.from(message.matchAll(matcher), ([, name]) => name.trim());
+}
+
+/**
+ * Returns the placeholders in the reported messages but
+ * only includes the placeholders available in the raw message and not in the provided data.
+ * @param {string} message The reported message
+ * @param {string} raw The raw message specified in the rule meta.messages
+ * @param {undefined|Record<unknown, unknown>} data The passed
+ * @returns {string[]} Missing placeholder names
+ */
+function getUnsubstitutedMessagePlaceholders(message, raw, data = {}) {
+    const unsubstituted = getMessagePlaceholders(message);
+
+    if (unsubstituted.length === 0) {
+        return [];
+    }
+
+    // Remove false positives by only counting placeholders in the raw message, which were not provided in the data matcher or added with a data property
+    const known = getMessagePlaceholders(raw);
+    const provided = Object.keys(data);
+
+    return unsubstituted.filter(name => known.includes(name) && !provided.includes(name));
+}
+
 const metaSchemaDescription = `
 \t- If the rule has options, set \`meta.schema\` to an array or non-empty object to enable options validation.
 \t- If the rule doesn't have options, omit \`meta.schema\` to enforce that no options can be passed to the rule.
@@ -645,7 +679,11 @@ class RuleTester {
                 configs.push(itemConfig);
             }
 
-            if (item.filename) {
+            if (hasOwnProperty(item, "only")) {
+                assert.ok(typeof item.only === "boolean", "Optional test case property 'only' must be a boolean");
+            }
+            if (hasOwnProperty(item, "filename")) {
+                assert.ok(typeof item.filename === "string", "Optional test case property 'filename' must be a string");
                 filename = item.filename;
             }
 
@@ -960,6 +998,7 @@ class RuleTester {
 
                         // Just an error message.
                         assertMessageMatches(message.message, error);
+                        assert.ok(message.suggestions === void 0, `Error at index ${i} has suggestions. Please convert the test error into an object and specify 'suggestions' property on it to test suggestions.`);
                     } else if (typeof error === "object" && error !== null) {
 
                         /*
@@ -992,6 +1031,18 @@ class RuleTester {
                                 error.messageId,
                                 `messageId '${message.messageId}' does not match expected messageId '${error.messageId}'.`
                             );
+
+                            const unsubstitutedPlaceholders = getUnsubstitutedMessagePlaceholders(
+                                message.message,
+                                rule.meta.messages[message.messageId],
+                                error.data
+                            );
+
+                            assert.ok(
+                                unsubstitutedPlaceholders.length === 0,
+                                `The reported message has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(", ")}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? "values" : "value"} via the 'data' property in the context.report() call.`
+                            );
+
                             if (hasOwnProperty(error, "data")) {
 
                                 /*
@@ -1008,13 +1059,10 @@ class RuleTester {
                                     `Hydrated message "${rehydratedMessage}" does not match "${message.message}"`
                                 );
                             }
+                        } else {
+                            assert.fail("Test error must specify either a 'messageId' or 'message'.");
                         }
 
-                        assert.ok(
-                            hasOwnProperty(error, "data") ? hasOwnProperty(error, "messageId") : true,
-                            "Error must specify 'messageId' if 'data' is used."
-                        );
-
                         if (error.type) {
                             assert.strictEqual(message.nodeType, error.type, `Error type should be ${error.type}, found ${message.nodeType}`);
                         }
@@ -1035,81 +1083,103 @@ class RuleTester {
                             assert.strictEqual(message.endColumn, error.endColumn, `Error endColumn should be ${error.endColumn}`);
                         }
 
+                        assert.ok(!message.suggestions || hasOwnProperty(error, "suggestions"), `Error at index ${i} has suggestions. Please specify 'suggestions' property on the test error object.`);
                         if (hasOwnProperty(error, "suggestions")) {
 
                             // Support asserting there are no suggestions
-                            if (!error.suggestions || (Array.isArray(error.suggestions) && error.suggestions.length === 0)) {
-                                if (Array.isArray(message.suggestions) && message.suggestions.length > 0) {
-                                    assert.fail(`Error should have no suggestions on error with message: "${message.message}"`);
-                                }
-                            } else {
-                                assert.strictEqual(Array.isArray(message.suggestions), true, `Error should have an array of suggestions. Instead received "${message.suggestions}" on error with message: "${message.message}"`);
-                                assert.strictEqual(message.suggestions.length, error.suggestions.length, `Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`);
-
-                                error.suggestions.forEach((expectedSuggestion, index) => {
-                                    assert.ok(
-                                        typeof expectedSuggestion === "object" && expectedSuggestion !== null,
-                                        "Test suggestion in 'suggestions' array must be an object."
-                                    );
-                                    Object.keys(expectedSuggestion).forEach(propertyName => {
-                                        assert.ok(
-                                            suggestionObjectParameters.has(propertyName),
-                                            `Invalid suggestion property name '${propertyName}'. Expected one of ${friendlySuggestionObjectParameterList}.`
-                                        );
-                                    });
-
-                                    const actualSuggestion = message.suggestions[index];
-                                    const suggestionPrefix = `Error Suggestion at index ${index} :`;
-
-                                    if (hasOwnProperty(expectedSuggestion, "desc")) {
+                            const expectsSuggestions = Array.isArray(error.suggestions) ? error.suggestions.length > 0 : Boolean(error.suggestions);
+                            const hasSuggestions = message.suggestions !== void 0;
+
+                            if (!hasSuggestions && expectsSuggestions) {
+                                assert.ok(!error.suggestions, `Error should have suggestions on error with message: "${message.message}"`);
+                            } else if (hasSuggestions) {
+                                assert.ok(expectsSuggestions, `Error should have no suggestions on error with message: "${message.message}"`);
+                                if (typeof error.suggestions === "number") {
+                                    assert.strictEqual(message.suggestions.length, error.suggestions, `Error should have ${error.suggestions} suggestions. Instead found ${message.suggestions.length} suggestions`);
+                                } else if (Array.isArray(error.suggestions)) {
+                                    assert.strictEqual(message.suggestions.length, error.suggestions.length, `Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`);
+
+                                    error.suggestions.forEach((expectedSuggestion, index) => {
                                         assert.ok(
-                                            !hasOwnProperty(expectedSuggestion, "data"),
-                                            `${suggestionPrefix} Test should not specify both 'desc' and 'data'.`
+                                            typeof expectedSuggestion === "object" && expectedSuggestion !== null,
+                                            "Test suggestion in 'suggestions' array must be an object."
                                         );
-                                        assert.strictEqual(
-                                            actualSuggestion.desc,
-                                            expectedSuggestion.desc,
-                                            `${suggestionPrefix} desc should be "${expectedSuggestion.desc}" but got "${actualSuggestion.desc}" instead.`
-                                        );
-                                    }
+                                        Object.keys(expectedSuggestion).forEach(propertyName => {
+                                            assert.ok(
+                                                suggestionObjectParameters.has(propertyName),
+                                                `Invalid suggestion property name '${propertyName}'. Expected one of ${friendlySuggestionObjectParameterList}.`
+                                            );
+                                        });
 
-                                    if (hasOwnProperty(expectedSuggestion, "messageId")) {
-                                        assert.ok(
-                                            ruleHasMetaMessages,
-                                            `${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`
-                                        );
-                                        assert.ok(
-                                            hasOwnProperty(rule.meta.messages, expectedSuggestion.messageId),
-                                            `${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`
-                                        );
-                                        assert.strictEqual(
-                                            actualSuggestion.messageId,
-                                            expectedSuggestion.messageId,
-                                            `${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`
-                                        );
-                                        if (hasOwnProperty(expectedSuggestion, "data")) {
-                                            const unformattedMetaMessage = rule.meta.messages[expectedSuggestion.messageId];
-                                            const rehydratedDesc = interpolate(unformattedMetaMessage, expectedSuggestion.data);
+                                        const actualSuggestion = message.suggestions[index];
+                                        const suggestionPrefix = `Error Suggestion at index ${index}:`;
 
+                                        if (hasOwnProperty(expectedSuggestion, "desc")) {
+                                            assert.ok(
+                                                !hasOwnProperty(expectedSuggestion, "data"),
+                                                `${suggestionPrefix} Test should not specify both 'desc' and 'data'.`
+                                            );
+                                            assert.ok(
+                                                !hasOwnProperty(expectedSuggestion, "messageId"),
+                                                `${suggestionPrefix} Test should not specify both 'desc' and 'messageId'.`
+                                            );
                                             assert.strictEqual(
                                                 actualSuggestion.desc,
-                                                rehydratedDesc,
-                                                `${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`
+                                                expectedSuggestion.desc,
+                                                `${suggestionPrefix} desc should be "${expectedSuggestion.desc}" but got "${actualSuggestion.desc}" instead.`
+                                            );
+                                        } else if (hasOwnProperty(expectedSuggestion, "messageId")) {
+                                            assert.ok(
+                                                ruleHasMetaMessages,
+                                                `${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`
+                                            );
+                                            assert.ok(
+                                                hasOwnProperty(rule.meta.messages, expectedSuggestion.messageId),
+                                                `${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`
+                                            );
+                                            assert.strictEqual(
+                                                actualSuggestion.messageId,
+                                                expectedSuggestion.messageId,
+                                                `${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`
+                                            );
+
+                                            const unsubstitutedPlaceholders = getUnsubstitutedMessagePlaceholders(
+                                                actualSuggestion.desc,
+                                                rule.meta.messages[expectedSuggestion.messageId],
+                                                expectedSuggestion.data
+                                            );
+
+                                            assert.ok(
+                                                unsubstitutedPlaceholders.length === 0,
+                                                `The message of the suggestion has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(", ")}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? "values" : "value"} via the 'data' property for the suggestion in the context.report() call.`
+                                            );
+
+                                            if (hasOwnProperty(expectedSuggestion, "data")) {
+                                                const unformattedMetaMessage = rule.meta.messages[expectedSuggestion.messageId];
+                                                const rehydratedDesc = interpolate(unformattedMetaMessage, expectedSuggestion.data);
+
+                                                assert.strictEqual(
+                                                    actualSuggestion.desc,
+                                                    rehydratedDesc,
+                                                    `${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`
+                                                );
+                                            }
+                                        } else if (hasOwnProperty(expectedSuggestion, "data")) {
+                                            assert.fail(
+                                                `${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`
+                                            );
+                                        } else {
+                                            assert.fail(
+                                                `${suggestionPrefix} Test must specify either 'messageId' or 'desc'.`
                                             );
                                         }
-                                    } else {
-                                        assert.ok(
-                                            !hasOwnProperty(expectedSuggestion, "data"),
-                                            `${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`
-                                        );
-                                    }
 
-                                    if (hasOwnProperty(expectedSuggestion, "output")) {
+                                        assert.ok(hasOwnProperty(expectedSuggestion, "output"), `${suggestionPrefix} The "output" property is required.`);
                                         const codeWithAppliedSuggestion = SourceCodeFixer.applyFixes(item.code, [actualSuggestion]).output;
 
                                         // Verify if suggestion fix makes a syntax error or not.
                                         const errorMessageInSuggestion =
-                                            linter.verify(codeWithAppliedSuggestion, result.configs, result.filename).find(m => m.fatal);
+                                                linter.verify(codeWithAppliedSuggestion, result.configs, result.filename).find(m => m.fatal);
 
                                         assert(!errorMessageInSuggestion, [
                                             "A fatal parsing error occurred in suggestion fix.",
@@ -1119,8 +1189,11 @@ class RuleTester {
                                         ].join("\n"));
 
                                         assert.strictEqual(codeWithAppliedSuggestion, expectedSuggestion.output, `Expected the applied suggestion fix to match the test suggestion output for suggestion at index: ${index} on error with message: "${message.message}"`);
-                                    }
-                                });
+                                        assert.notStrictEqual(expectedSuggestion.output, item.code, `The output of a suggestion should differ from the original source code for suggestion at index: ${index} on error with message: "${message.message}"`);
+                                    });
+                                } else {
+                                    assert.fail("Test error object property 'suggestions' should be an array or a number");
+                                }
                             }
                         }
                     } else {
@@ -1140,6 +1213,7 @@ class RuleTester {
                     );
                 } else {
                     assert.strictEqual(result.output, item.output, "Output is incorrect.");
+                    assert.notStrictEqual(item.code, item.output, "Test property 'output' matches 'code'. If no autofix is expected, then omit the 'output' property or set it to null.");
                 }
             } else {
                 assert.strictEqual(

package/lib/rules/no-constant-binary-expression.js

@@ -5,8 +5,7 @@
 
 "use strict";
 
-const globals = require("globals");
-const { isNullLiteral, isConstant, isReferenceToGlobalVariable, isLogicalAssignmentOperator } = require("./utils/ast-utils");
+const { isNullLiteral, isConstant, isReferenceToGlobalVariable, isLogicalAssignmentOperator, ECMASCRIPT_GLOBALS } = require("./utils/ast-utils");
 
 const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set(["+", "-", "*", "/", "%", "|", "^", "&", "**", "<<", ">>", ">>>"]);
 
@@ -376,7 +375,7 @@ function isAlwaysNew(scope, node) {
              * Catching these is especially useful for primitive constructors
              * which return boxed values, a surprising gotcha' in JavaScript.
              */
-            return Object.hasOwn(globals.builtin, node.callee.name) &&
+            return Object.hasOwn(ECMASCRIPT_GLOBALS, node.callee.name) &&
               isReferenceToGlobalVariable(scope, node.callee);
         }
         case "Literal":

package/lib/rules/no-extend-native.js

@@ -10,7 +10,6 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const globals = require("globals");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -54,7 +53,7 @@ module.exports = {
         const sourceCode = context.sourceCode;
         const exceptions = new Set(config.exceptions || []);
         const modifiedBuiltins = new Set(
-            Object.keys(globals.builtin)
+            Object.keys(astUtils.ECMASCRIPT_GLOBALS)
                 .filter(builtin => builtin[0].toUpperCase() === builtin[0])
                 .filter(builtin => !exceptions.has(builtin))
         );

package/lib/rules/no-unused-vars.js

@@ -92,7 +92,7 @@ module.exports = {
             vars: "all",
             args: "after-used",
             ignoreRestSiblings: false,
-            caughtErrors: "none"
+            caughtErrors: "all"
         };
 
         const firstOption = context.options[0];

package/lib/rules/no-useless-computed-key.js

@@ -101,7 +101,7 @@ module.exports = {
             properties: {
                 enforceForClassMembers: {
                     type: "boolean",
-                    default: false
+                    default: true
                 }
             },
             additionalProperties: false
@@ -114,7 +114,7 @@ module.exports = {
     },
     create(context) {
         const sourceCode = context.sourceCode;
-        const enforceForClassMembers = context.options[0] && context.options[0].enforceForClassMembers;
+        const enforceForClassMembers = context.options[0]?.enforceForClassMembers ?? true;
 
         /**
          * Reports a given node if it violated this rule.

package/lib/rules/use-isnan.js

@@ -21,9 +21,17 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} `true` if the node is 'NaN' identifier.
  */
 function isNaNIdentifier(node) {
-    return Boolean(node) && (
-        astUtils.isSpecificId(node, "NaN") ||
-        astUtils.isSpecificMemberAccess(node, "Number", "NaN")
+    if (!node) {
+        return false;
+    }
+
+    const nodeToCheck = node.type === "SequenceExpression"
+        ? node.expressions.at(-1)
+        : node;
+
+    return (
+        astUtils.isSpecificId(nodeToCheck, "NaN") ||
+        astUtils.isSpecificMemberAccess(nodeToCheck, "Number", "NaN")
     );
 }
 
@@ -34,6 +42,7 @@ function isNaNIdentifier(node) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        hasSuggestions: true,
         type: "problem",
 
         docs: {
@@ -63,7 +72,10 @@ module.exports = {
             comparisonWithNaN: "Use the isNaN function to compare with NaN.",
             switchNaN: "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.",
             caseNaN: "'case NaN' can never match. Use Number.isNaN before the switch.",
-            indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN."
+            indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN.",
+            replaceWithIsNaN: "Replace with Number.isNaN.",
+            replaceWithCastingAndIsNaN: "Replace with Number.isNaN and cast to a Number.",
+            replaceWithFindIndex: "Replace with Array.prototype.{{ methodName }}."
         }
     },
 
@@ -71,6 +83,35 @@ module.exports = {
 
         const enforceForSwitchCase = !context.options[0] || context.options[0].enforceForSwitchCase;
         const enforceForIndexOf = context.options[0] && context.options[0].enforceForIndexOf;
+        const sourceCode = context.sourceCode;
+
+        const fixableOperators = new Set(["==", "===", "!=", "!=="]);
+        const castableOperators = new Set(["==", "!="]);
+
+        /**
+         * Get a fixer for a binary expression that compares to NaN.
+         * @param  {ASTNode} node The node to fix.
+         * @param {function(string): string} wrapValue A function that wraps the compared value with a fix.
+         * @returns {function(Fixer): Fix} The fixer function.
+         */
+        function getBinaryExpressionFixer(node, wrapValue) {
+            return fixer => {
+                const comparedValue = isNaNIdentifier(node.left) ? node.right : node.left;
+                const shouldWrap = comparedValue.type === "SequenceExpression";
+                const shouldNegate = node.operator[0] === "!";
+
+                const negation = shouldNegate ? "!" : "";
+                let comparedValueText = sourceCode.getText(comparedValue);
+
+                if (shouldWrap) {
+                    comparedValueText = `(${comparedValueText})`;
+                }
+
+                const fixedValue = wrapValue(comparedValueText);
+
+                return fixer.replaceText(node, `${negation}${fixedValue}`);
+            };
+        }
 
         /**
          * Checks the given `BinaryExpression` node for `foo === NaN` and other comparisons.
@@ -82,7 +123,32 @@ module.exports = {
                 /^(?:[<>]|[!=]=)=?$/u.test(node.operator) &&
                 (isNaNIdentifier(node.left) || isNaNIdentifier(node.right))
             ) {
-                context.report({ node, messageId: "comparisonWithNaN" });
+                const suggestedFixes = [];
+                const NaNNode = isNaNIdentifier(node.left) ? node.left : node.right;
+
+                const isSequenceExpression = NaNNode.type === "SequenceExpression";
+                const isSuggestable = fixableOperators.has(node.operator) && !isSequenceExpression;
+                const isCastable = castableOperators.has(node.operator);
+
+                if (isSuggestable) {
+                    suggestedFixes.push({
+                        messageId: "replaceWithIsNaN",
+                        fix: getBinaryExpressionFixer(node, value => `Number.isNaN(${value})`)
+                    });
+
+                    if (isCastable) {
+                        suggestedFixes.push({
+                            messageId: "replaceWithCastingAndIsNaN",
+                            fix: getBinaryExpressionFixer(node, value => `Number.isNaN(Number(${value}))`)
+                        });
+                    }
+                }
+
+                context.report({
+                    node,
+                    messageId: "comparisonWithNaN",
+                    suggest: suggestedFixes
+                });
             }
         }
 
@@ -119,7 +185,35 @@ module.exports = {
                     node.arguments.length === 1 &&
                     isNaNIdentifier(node.arguments[0])
                 ) {
-                    context.report({ node, messageId: "indexOfNaN", data: { methodName } });
+
+                    /*
+                     * To retain side effects, it's essential to address `NaN` beforehand, which
+                     * is not possible with fixes like `arr.findIndex(Number.isNaN)`.
+                     */
+                    const isSuggestable = node.arguments[0].type !== "SequenceExpression";
+                    const suggestedFixes = [];
+
+                    if (isSuggestable) {
+                        const shouldWrap = callee.computed;
+                        const findIndexMethod = methodName === "indexOf" ? "findIndex" : "findLastIndex";
+                        const propertyName = shouldWrap ? `"${findIndexMethod}"` : findIndexMethod;
+
+                        suggestedFixes.push({
+                            messageId: "replaceWithFindIndex",
+                            data: { methodName: findIndexMethod },
+                            fix: fixer => [
+                                fixer.replaceText(callee.property, propertyName),
+                                fixer.replaceText(node.arguments[0], "Number.isNaN")
+                            ]
+                        });
+                    }
+
+                    context.report({
+                        node,
+                        messageId: "indexOfNaN",
+                        data: { methodName },
+                        suggest: suggestedFixes
+                    });
                 }
             }
         }

package/lib/rules/utils/ast-utils.js

@@ -19,6 +19,8 @@ const {
     lineBreakPattern,
     shebangPattern
 } = require("../../shared/ast-utils");
+const globals = require("../../../conf/globals");
+const { LATEST_ECMA_VERSION } = require("../../../conf/ecma-version");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -46,6 +48,12 @@ const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN = /^(?:[^\\]|\\.)*\\(?:[1-9]|0[0
 
 const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
 
+/**
+ * All builtin global variables defined in the latest ECMAScript specification.
+ * @type {Record<string,boolean>} Key is the name of the variable. Value is `true` if the variable is considered writable, `false` otherwise.
+ */
+const ECMASCRIPT_GLOBALS = globals[`es${LATEST_ECMA_VERSION}`];
+
 /**
  * Checks reference if is non initializer and writable.
  * @param {Reference} reference A reference to check.
@@ -1133,6 +1141,7 @@ module.exports = {
     LINEBREAK_MATCHER: lineBreakPattern,
     SHEBANG_MATCHER: shebangPattern,
     STATEMENT_LIST_PARENTS,
+    ECMASCRIPT_GLOBALS,
 
     /**
      * Determines whether two adjacent tokens are on the same line.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.0.0-alpha.2",
+  "version": "9.0.0-beta.1",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -65,8 +65,8 @@
   "dependencies": {
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.6.1",
-    "@eslint/eslintrc": "^3.0.0",
-    "@eslint/js": "9.0.0-alpha.2",
+    "@eslint/eslintrc": "^3.0.2",
+    "@eslint/js": "9.0.0-beta.1",
     "@humanwhocodes/config-array": "^0.11.14",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
@@ -76,15 +76,14 @@
     "debug": "^4.3.2",
     "escape-string-regexp": "^4.0.0",
     "eslint-scope": "^8.0.0",
-    "eslint-visitor-keys": "^3.4.3",
-    "espree": "^10.0.0",
+    "eslint-visitor-keys": "^4.0.0",
+    "espree": "^10.0.1",
     "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
-    "file-entry-cache": "^6.0.1",
+    "file-entry-cache": "^8.0.0",
     "find-up": "^5.0.0",
     "glob-parent": "^6.0.2",
-    "globals": "^13.19.0",
     "graphemer": "^1.4.0",
     "ignore": "^5.2.0",
     "imurmurhash": "^0.1.4",
@@ -122,12 +121,13 @@
     "eslint-plugin-jsdoc": "^46.9.0",
     "eslint-plugin-n": "^16.6.0",
     "eslint-plugin-unicorn": "^49.0.0",
-    "eslint-release": "^3.2.0",
+    "eslint-release": "^3.2.2",
     "eslump": "^3.0.0",
     "esprima": "^4.0.1",
     "fast-glob": "^3.2.11",
     "fs-teardown": "^0.1.3",
     "glob": "^10.0.0",
+    "globals": "^14.0.0",
     "got": "^11.8.3",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
@@ -136,7 +136,7 @@
     "markdown-it": "^12.2.0",
     "markdown-it-container": "^3.0.0",
     "markdownlint": "^0.33.0",
-    "markdownlint-cli": "^0.38.0",
+    "markdownlint-cli": "^0.39.0",
     "marked": "^4.0.8",
     "memfs": "^3.0.1",
     "metascraper": "^5.25.7",
@@ -155,7 +155,7 @@
     "regenerator-runtime": "^0.14.0",
     "rollup-plugin-node-polyfills": "^0.2.1",
     "semver": "^7.5.3",
-    "shelljs": "^0.8.2",
+    "shelljs": "^0.8.5",
     "sinon": "^11.0.0",
     "vite-plugin-commonjs": "^0.10.0",
     "webdriverio": "^8.14.6",