eslint 8.56.0 → 9.0.0-alpha.1

package/lib/linter/linter.js

@@ -52,6 +52,7 @@ const DEFAULT_ECMA_VERSION = 5;
 const commentParser = new ConfigCommentParser();
 const DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } };
 const parserSymbol = Symbol.for("eslint.RuleTester.parser");
+const { LATEST_ECMA_VERSION } = require("../../conf/ecma-version");
 
 //------------------------------------------------------------------------------
 // Typedefs
@@ -105,6 +106,7 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
  * @property {string} [filename] the filename of the source code.
  * @property {boolean | "off" | "warn" | "error"} [reportUnusedDisableDirectives] Adds reported errors for
  *      unused `eslint-disable` directives.
+ * @property {Function} [ruleFilter] A predicate function that determines whether a given rule should run.
  */
 
 /**
@@ -230,7 +232,7 @@ function addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, ena
  * @private
  */
 function createMissingRuleMessage(ruleId) {
-    return Object.prototype.hasOwnProperty.call(ruleReplacements.rules, ruleId)
+    return Object.hasOwn(ruleReplacements.rules, ruleId)
         ? `Rule '${ruleId}' was removed and replaced by: ${ruleReplacements.rules[ruleId].join(", ")}`
         : `Definition for rule '${ruleId}' was not found.`;
 }
@@ -392,7 +394,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
             }
 
             case "exported":
-                Object.assign(exportedVariables, commentParser.parseStringConfig(directiveValue, comment));
+                Object.assign(exportedVariables, commentParser.parseListConfig(directiveValue, comment));
                 break;
 
             case "globals":
@@ -439,6 +441,15 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                         try {
                             validator.validateRuleOptions(rule, name, ruleValue);
                         } catch (err) {
+
+                            /*
+                             * If the rule has invalid `meta.schema`, throw the error because
+                             * this is not an invalid inline configuration but an invalid rule.
+                             */
+                            if (err.code === "ESLINT_INVALID_RULE_OPTIONS_SCHEMA") {
+                                throw err;
+                            }
+
                             problems.push(createLintingProblem({
                                 ruleId: name,
                                 message: err.message,
@@ -584,7 +595,7 @@ function normalizeEcmaVersionForLanguageOptions(ecmaVersion) {
      * that is used for a number of processes inside of ESLint. It's normally
      * safe to assume people want the latest unless otherwise specified.
      */
-    return espree.latestEcmaVersion + 2009;
+    return LATEST_ECMA_VERSION;
 }
 
 const eslintEnvPattern = /\/\*\s*eslint-env\s(.+?)(?:\*\/|$)/gsu;
@@ -661,6 +672,12 @@ function normalizeVerifyOptions(providedOptions, config) {
         }
     }
 
+    let ruleFilter = providedOptions.ruleFilter;
+
+    if (typeof ruleFilter !== "function") {
+        ruleFilter = () => true;
+    }
+
     return {
         filename: normalizeFilename(providedOptions.filename || "<input>"),
         allowInlineConfig: !ignoreInlineConfig,
@@ -668,7 +685,8 @@ function normalizeVerifyOptions(providedOptions, config) {
             ? `your config${configNameOfNoInlineConfig}`
             : null,
         reportUnusedDisableDirectives,
-        disableFixes: Boolean(providedOptions.disableFixes)
+        disableFixes: Boolean(providedOptions.disableFixes),
+        ruleFilter
     };
 }
 
@@ -885,12 +903,18 @@ function parse(text, languageOptions, filePath) {
 
 /**
  * Runs a rule, and gets its listeners
- * @param {Rule} rule A normalized rule with a `create` method
+ * @param {Rule} rule A rule object
  * @param {Context} ruleContext The context that should be passed to the rule
+ * @throws {TypeError} If `rule` is not an object with a `create` method
  * @throws {any} Any error during the rule's `create`
  * @returns {Object} A map of selector listeners provided by the rule
  */
 function createRuleListeners(rule, ruleContext) {
+
+    if (!rule || typeof rule !== "object" || typeof rule.create !== "function") {
+        throw new TypeError(`Error while loading rule '${ruleContext.id}': Rule must be an object with a \`create\` method`);
+    }
+
     try {
         return rule.create(ruleContext);
     } catch (ex) {
@@ -899,43 +923,6 @@ function createRuleListeners(rule, ruleContext) {
     }
 }
 
-// methods that exist on SourceCode object
-const DEPRECATED_SOURCECODE_PASSTHROUGHS = {
-    getSource: "getText",
-    getSourceLines: "getLines",
-    getAllComments: "getAllComments",
-    getNodeByRangeIndex: "getNodeByRangeIndex",
-    getComments: "getComments",
-    getCommentsBefore: "getCommentsBefore",
-    getCommentsAfter: "getCommentsAfter",
-    getCommentsInside: "getCommentsInside",
-    getJSDocComment: "getJSDocComment",
-    getFirstToken: "getFirstToken",
-    getFirstTokens: "getFirstTokens",
-    getLastToken: "getLastToken",
-    getLastTokens: "getLastTokens",
-    getTokenAfter: "getTokenAfter",
-    getTokenBefore: "getTokenBefore",
-    getTokenByRangeStart: "getTokenByRangeStart",
-    getTokens: "getTokens",
-    getTokensAfter: "getTokensAfter",
-    getTokensBefore: "getTokensBefore",
-    getTokensBetween: "getTokensBetween"
-};
-
-
-const BASE_TRAVERSAL_CONTEXT = Object.freeze(
-    Object.keys(DEPRECATED_SOURCECODE_PASSTHROUGHS).reduce(
-        (contextInfo, methodName) =>
-            Object.assign(contextInfo, {
-                [methodName](...args) {
-                    return this.sourceCode[DEPRECATED_SOURCECODE_PASSTHROUGHS[methodName]](...args);
-                }
-            }),
-        {}
-    )
-);
-
 /**
  * Runs the given rules on the given SourceCode object
  * @param {SourceCode} sourceCode A SourceCode object for the given text
@@ -948,9 +935,10 @@ const BASE_TRAVERSAL_CONTEXT = Object.freeze(
  * @param {boolean} disableFixes If true, it doesn't make `fix` properties.
  * @param {string | undefined} cwd cwd of the cli
  * @param {string} physicalFilename The full path of the file on disk without any code block information
+ * @param {Function} ruleFilter A predicate function to filter which rules should be executed.
  * @returns {LintMessage[]} An array of reported problems
  */
-function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageOptions, settings, filename, disableFixes, cwd, physicalFilename) {
+function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageOptions, settings, filename, disableFixes, cwd, physicalFilename, ruleFilter) {
     const emitter = createEmitter();
     const nodeQueue = [];
     let currentNode = sourceCode.ast;
@@ -972,30 +960,22 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
      * properties once for each rule.
      */
     const sharedTraversalContext = Object.freeze(
-        Object.assign(
-            Object.create(BASE_TRAVERSAL_CONTEXT),
-            {
-                getAncestors: () => sourceCode.getAncestors(currentNode),
-                getDeclaredVariables: node => sourceCode.getDeclaredVariables(node),
-                getCwd: () => cwd,
-                cwd,
-                getFilename: () => filename,
-                filename,
-                getPhysicalFilename: () => physicalFilename || filename,
-                physicalFilename: physicalFilename || filename,
-                getScope: () => sourceCode.getScope(currentNode),
-                getSourceCode: () => sourceCode,
-                sourceCode,
-                markVariableAsUsed: name => sourceCode.markVariableAsUsed(name, currentNode),
-                parserOptions: {
-                    ...languageOptions.parserOptions
-                },
-                parserPath: parserName,
-                languageOptions,
-                parserServices: sourceCode.parserServices,
-                settings
-            }
-        )
+        {
+            getCwd: () => cwd,
+            cwd,
+            getFilename: () => filename,
+            filename,
+            getPhysicalFilename: () => physicalFilename || filename,
+            physicalFilename: physicalFilename || filename,
+            getSourceCode: () => sourceCode,
+            sourceCode,
+            parserOptions: {
+                ...languageOptions.parserOptions
+            },
+            parserPath: parserName,
+            languageOptions,
+            settings
+        }
     );
 
     const lintingProblems = [];
@@ -1008,6 +988,10 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
             return;
         }
 
+        if (ruleFilter && !ruleFilter({ ruleId, severity })) {
+            return;
+        }
+
         const rule = ruleMapper(ruleId);
 
         if (!rule) {
@@ -1217,9 +1201,9 @@ class Linter {
      * Initialize the Linter.
      * @param {Object} [config] the config object
      * @param {string} [config.cwd] path to a directory that should be considered as the current working directory, can be undefined.
-     * @param {"flat"|"eslintrc"} [config.configType="eslintrc"] the type of config used.
+     * @param {"flat"|"eslintrc"} [config.configType="flat"] the type of config used.
      */
-    constructor({ cwd, configType } = {}) {
+    constructor({ cwd, configType = "flat" } = {}) {
         internalSlotsMap.set(this, {
             cwd: normalizeCwd(cwd),
             lastConfigArray: null,
@@ -1348,7 +1332,56 @@ 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 {
@@ -1362,7 +1395,8 @@ class Linter {
                 options.filename,
                 options.disableFixes,
                 slots.cwd,
-                providedOptions.physicalFilename
+                providedOptions.physicalFilename,
+                null
             );
         } catch (err) {
             err.message += `\nOccurred while linting ${options.filename}`;
@@ -1413,29 +1447,29 @@ class Linter {
             ? { filename: filenameOrOptions }
             : filenameOrOptions || {};
 
-        if (config) {
-            if (configType === "flat") {
-
-                /*
-                 * Because of how Webpack packages up the files, we can't
-                 * compare directly to `FlatConfigArray` using `instanceof`
-                 * because it's not the same `FlatConfigArray` as in the tests.
-                 * So, we work around it by assuming an array is, in fact, a
-                 * `FlatConfigArray` if it has a `getConfig()` method.
-                 */
-                let configArray = config;
-
-                if (!Array.isArray(config) || typeof config.getConfig !== "function") {
-                    configArray = new FlatConfigArray(config, { basePath: cwd });
-                    configArray.normalizeSync();
-                }
+        const configToUse = config ?? {};
 
-                return this._distinguishSuppressedMessages(this._verifyWithFlatConfigArray(textOrSourceCode, configArray, options, true));
-            }
+        if (configType !== "eslintrc") {
 
-            if (typeof config.extractConfig === "function") {
-                return this._distinguishSuppressedMessages(this._verifyWithConfigArray(textOrSourceCode, config, options));
+            /*
+             * Because of how Webpack packages up the files, we can't
+             * compare directly to `FlatConfigArray` using `instanceof`
+             * because it's not the same `FlatConfigArray` as in the tests.
+             * So, we work around it by assuming an array is, in fact, a
+             * `FlatConfigArray` if it has a `getConfig()` method.
+             */
+            let configArray = configToUse;
+
+            if (!Array.isArray(configToUse) || typeof configToUse.getConfig !== "function") {
+                configArray = new FlatConfigArray(configToUse, { basePath: cwd });
+                configArray.normalizeSync();
             }
+
+            return this._distinguishSuppressedMessages(this._verifyWithFlatConfigArray(textOrSourceCode, configArray, options, true));
+        }
+
+        if (typeof configToUse.extractConfig === "function") {
+            return this._distinguishSuppressedMessages(this._verifyWithConfigArray(textOrSourceCode, configToUse, options));
         }
 
         /*
@@ -1448,9 +1482,9 @@ class Linter {
          * So we cannot apply multiple processors.
          */
         if (options.preprocess || options.postprocess) {
-            return this._distinguishSuppressedMessages(this._verifyWithProcessor(textOrSourceCode, config, options));
+            return this._distinguishSuppressedMessages(this._verifyWithProcessor(textOrSourceCode, configToUse, options));
         }
-        return this._distinguishSuppressedMessages(this._verifyWithoutProcessors(textOrSourceCode, config, options));
+        return this._distinguishSuppressedMessages(this._verifyWithoutProcessors(textOrSourceCode, configToUse, options));
     }
 
     /**
@@ -1690,9 +1724,17 @@ class Linter {
                                     [ruleId]: ruleOptions
                                 }
                             });
-                            mergedInlineConfig.rules[ruleId] = ruleValue;
+                            mergedInlineConfig.rules[ruleId] = ruleOptions;
                         } catch (err) {
 
+                            /*
+                             * If the rule has invalid `meta.schema`, throw the error because
+                             * this is not an invalid inline configuration but an invalid rule.
+                             */
+                            if (err.code === "ESLINT_INVALID_RULE_OPTIONS_SCHEMA") {
+                                throw err;
+                            }
+
                             let baseMessage = err.message.slice(
                                 err.message.startsWith("Key \"rules\":")
                                     ? err.message.indexOf(":", 12) + 1
@@ -1721,7 +1763,58 @@ 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();
@@ -1737,7 +1830,8 @@ class Linter {
                 options.filename,
                 options.disableFixes,
                 slots.cwd,
-                providedOptions.physicalFilename
+                providedOptions.physicalFilename,
+                options.ruleFilter
             );
         } catch (err) {
             err.message += `\nOccurred while linting ${options.filename}`;
@@ -1768,7 +1862,9 @@ class Linter {
                 .concat(commentDirectives.problems)
                 .concat(inlineConfigProblems)
                 .sort((problemA, problemB) => problemA.line - problemB.line || problemA.column - problemB.column),
-            reportUnusedDisableDirectives: options.reportUnusedDisableDirectives
+            reportUnusedDisableDirectives: options.reportUnusedDisableDirectives,
+            ruleFilter: options.ruleFilter,
+            configuredRules
         });
     }
 
@@ -1986,17 +2082,17 @@ class Linter {
     /**
      * Defines a new linting rule.
      * @param {string} ruleId A unique rule identifier
-     * @param {Function | Rule} ruleModule Function from context to object mapping AST node types to event handlers
+     * @param {Rule} rule A rule object
      * @returns {void}
      */
-    defineRule(ruleId, ruleModule) {
+    defineRule(ruleId, rule) {
         assertEslintrcConfig(this);
-        internalSlotsMap.get(this).ruleMap.define(ruleId, ruleModule);
+        internalSlotsMap.get(this).ruleMap.define(ruleId, rule);
     }
 
     /**
      * Defines many new linting rules.
-     * @param {Record<string, Function | Rule>} rulesToDefine map from unique rule identifier to rule
+     * @param {Record<string, Rule>} rulesToDefine map from unique rule identifier to rule
      * @returns {void}
      */
     defineRules(rulesToDefine) {
@@ -2044,7 +2140,7 @@ class Linter {
      *      SourceCodeFixer.
      */
     verifyAndFix(text, config, options) {
-        let messages = [],
+        let messages,
             fixedResult,
             fixed = false,
             passNumber = 0,

package/lib/linter/report-translator.js

@@ -160,7 +160,7 @@ function mergeFixes(fixes, sourceCode) {
 
     const originalText = sourceCode.text;
     const start = fixes[0].range[0];
-    const end = fixes[fixes.length - 1].range[1];
+    const end = fixes.at(-1).range[1];
     let text = "";
     let lastPos = Number.MIN_SAFE_INTEGER;
 
@@ -343,7 +343,7 @@ module.exports = function createReportTranslator(metadata) {
             if (descriptor.message) {
                 throw new TypeError("context.report() called with a message and a messageId. Please only pass one.");
             }
-            if (!messages || !Object.prototype.hasOwnProperty.call(messages, id)) {
+            if (!messages || !Object.hasOwn(messages, id)) {
                 throw new TypeError(`context.report() called with a messageId of '${id}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`);
             }
             computedMessage = messages[id];

package/lib/linter/rules.js

@@ -13,18 +13,10 @@
 const builtInRules = require("../rules");
 
 //------------------------------------------------------------------------------
-// Helpers
+// Typedefs
 //------------------------------------------------------------------------------
 
-/**
- * Normalizes a rule module to the new-style API
- * @param {(Function|{create: Function})} rule A rule object, which can either be a function
- * ("old-style") or an object with a `create` method ("new-style")
- * @returns {{create: Function}} A new-style rule.
- */
-function normalizeRule(rule) {
-    return typeof rule === "function" ? Object.assign({ create: rule }, rule) : rule;
-}
+/** @typedef {import("../shared/types").Rule} Rule */
 
 //------------------------------------------------------------------------------
 // Public Interface
@@ -41,18 +33,17 @@ class Rules {
     /**
      * Registers a rule module for rule id in storage.
      * @param {string} ruleId Rule id (file name).
-     * @param {Function} ruleModule Rule handler.
+     * @param {Rule} rule Rule object.
      * @returns {void}
      */
-    define(ruleId, ruleModule) {
-        this._rules[ruleId] = normalizeRule(ruleModule);
+    define(ruleId, rule) {
+        this._rules[ruleId] = rule;
     }
 
     /**
      * Access rule handler by id (file name).
      * @param {string} ruleId Rule id (file name).
-     * @returns {{create: Function, schema: JsonSchema[]}}
-     * A rule. This is normalized to always have the new-style shape with a `create` method.
+     * @returns {Rule} Rule object.
      */
     get(ruleId) {
         if (typeof this._rules[ruleId] === "string") {

package/lib/linter/source-code-fixer.js

@@ -107,7 +107,7 @@ SourceCodeFixer.applyFixes = function(sourceText, messages, shouldFix) {
     }
 
     messages.forEach(problem => {
-        if (Object.prototype.hasOwnProperty.call(problem, "fix")) {
+        if (Object.hasOwn(problem, "fix")) {
             fixes.push(problem);
         } else {
             remainingMessages.push(problem);

package/lib/options.js

@@ -57,6 +57,8 @@ const optionator = require("optionator");
  * @property {boolean} quiet Report errors only
  * @property {boolean} [version] Output the version number
  * @property {boolean} warnIgnored Show warnings when the file list includes ignored files
+ * @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
  */
 
@@ -168,7 +170,7 @@ module.exports = function(usingFlatConfig) {
                 alias: "c",
                 type: "path::String",
                 description: usingFlatConfig
-                    ? "Use this configuration instead of eslint.config.js"
+                    ? "Use this configuration instead of eslint.config.js, eslint.config.mjs, or eslint.config.cjs"
                     : "Use this configuration, overriding .eslintrc.* config options if present"
             },
             envFlag,
@@ -370,6 +372,12 @@ module.exports = function(usingFlatConfig) {
                 description: "Exit with exit code 2 in case of fatal error"
             },
             warnIgnoredFlag,
+            {
+                option: "pass-on-no-patterns",
+                type: "Boolean",
+                default: false,
+                description: "Exit with exit code 0 in case no file patterns are passed"
+            },
             {
                 option: "debug",
                 type: "Boolean",