eslint 9.11.0 → 9.12.0

package/lib/eslint/eslint.js

@@ -12,7 +12,6 @@
 const fs = require("node:fs/promises");
 const { existsSync } = require("node:fs");
 const path = require("node:path");
-const findUp = require("find-up");
 const { version } = require("../../package.json");
 const { Linter } = require("../linter");
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
@@ -39,9 +38,9 @@ const {
     processOptions
 } = require("./eslint-helpers");
 const { pathToFileURL } = require("node:url");
-const { FlatConfigArray } = require("../config/flat-config-array");
 const LintResultCache = require("../cli-engine/lint-result-cache");
 const { Retrier } = require("@humanwhocodes/retry");
+const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
 
 /*
  * This is necessary to allow overwriting writeFile for testing purposes.
@@ -97,24 +96,8 @@ const { Retrier } = require("@humanwhocodes/retry");
 // Helpers
 //------------------------------------------------------------------------------
 
-const FLAT_CONFIG_FILENAMES = [
-    "eslint.config.js",
-    "eslint.config.mjs",
-    "eslint.config.cjs"
-];
-const FLAT_CONFIG_FILENAMES_WITH_TS = [
-    ...FLAT_CONFIG_FILENAMES,
-    "eslint.config.ts",
-    "eslint.config.mts",
-    "eslint.config.cts"
-];
 const debug = require("debug")("eslint:eslint");
 const privateMembers = new WeakMap();
-
-/**
- * @type {Map<string, string>}
- */
-const importedConfigFileModificationTime = new Map();
 const removedFormatters = new Set([
     "checkstyle",
     "codeframe",
@@ -196,12 +179,13 @@ const usedDeprecatedRulesCache = new WeakMap();
  */
 function getOrFindUsedDeprecatedRules(eslint, maybeFilePath) {
     const {
-        configs,
-        options: { cwd }
+        options: { cwd },
+        configLoader
     } = privateMembers.get(eslint);
     const filePath = path.isAbsolute(maybeFilePath)
         ? maybeFilePath
         : getPlaceholderPath(cwd);
+    const configs = configLoader.getCachedConfigArrayForFile(filePath);
     const config = configs.getConfig(filePath);
 
     // Most files use the same config, so cache it.
@@ -270,269 +254,38 @@ function compareResultsByFilePath(a, b) {
     return 0;
 }
 
-/**
- * Searches from the current working directory up until finding the
- * given flat config filename.
- * @param {string} cwd The current working directory to search from.
- * @param {boolean} hasUnstableTSConfigFlag `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
- * @returns {Promise<string|undefined>} The filename if found or `undefined` if not.
- */
-function findFlatConfigFile(cwd, hasUnstableTSConfigFlag) {
-    const filenames = hasUnstableTSConfigFlag ? FLAT_CONFIG_FILENAMES_WITH_TS : FLAT_CONFIG_FILENAMES;
-
-    return findUp(
-        filenames,
-        { cwd }
-    );
-}
-
-/**
- * Check if the file is a TypeScript file.
- * @param {string} filePath The file path to check.
- * @returns {boolean} `true` if the file is a TypeScript file, `false` if it's not.
- */
-function isFileTS(filePath) {
-    const fileExtension = path.extname(filePath);
-
-    return /^\.[mc]?ts$/u.test(fileExtension);
-}
-
-/**
- * Check if ESLint is running in Bun.
- * @returns {boolean} `true` if the ESLint is running Bun, `false` if it's not.
- */
-function isRunningInBun() {
-    return !!globalThis.Bun;
-}
-
-/**
- * Check if ESLint is running in Deno.
- * @returns {boolean} `true` if the ESLint is running in Deno, `false` if it's not.
- */
-function isRunningInDeno() {
-    return !!globalThis.Deno;
-}
-
-/**
- * Load the config array from the given filename.
- * @param {string} filePath The filename to load from.
- * @param {boolean} hasUnstableTSConfigFlag `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
- * @returns {Promise<any>} The config loaded from the config file.
- */
-async function loadFlatConfigFile(filePath, hasUnstableTSConfigFlag) {
-    debug(`Loading config from ${filePath}`);
-
-    const fileURL = pathToFileURL(filePath);
-
-    debug(`Config file URL is ${fileURL}`);
-
-    const mtime = (await fs.stat(filePath)).mtime.getTime().toString();
-
-    /*
-     * Append a query with the config file's modification time (`mtime`) in order
-     * to import the current version of the config file. Without the query, `import()` would
-     * cache the config file module by the pathname only, and then always return
-     * the same version (the one that was actual when the module was imported for the first time).
-     *
-     * This ensures that the config file module is loaded and executed again
-     * if it has been changed since the last time it was imported.
-     * If it hasn't been changed, `import()` will just return the cached version.
-     *
-     * Note that we should not overuse queries (e.g., by appending the current time
-     * to always reload the config file module) as that could cause memory leaks
-     * because entries are never removed from the import cache.
-     */
-    fileURL.searchParams.append("mtime", mtime);
-
-    /*
-     * With queries, we can bypass the import cache. However, when import-ing a CJS module,
-     * Node.js uses the require infrastructure under the hood. That includes the require cache,
-     * which caches the config file module by its file path (queries have no effect).
-     * Therefore, we also need to clear the require cache before importing the config file module.
-     * In order to get the same behavior with ESM and CJS config files, in particular - to reload
-     * the config file only if it has been changed, we track file modification times and clear
-     * the require cache only if the file has been changed.
-     */
-    if (importedConfigFileModificationTime.get(filePath) !== mtime) {
-        delete require.cache[filePath];
-    }
-
-    const isTS = isFileTS(filePath) && hasUnstableTSConfigFlag;
-
-    const isBun = isRunningInBun();
-
-    const isDeno = isRunningInDeno();
-
-    if (isTS && !isDeno && !isBun) {
-
-        const createJiti = await import("jiti").then(jitiModule => jitiModule.default, () => {
-            throw new Error("The 'jiti' library is required for loading TypeScript configuration files. Make sure to install it.");
-        });
-
-        /*
-         * Disabling `moduleCache` allows us to reload a
-         * config file when the last modified timestamp changes.
-         */
-
-        const jiti = createJiti(__filename, { moduleCache: false });
-
-        if (typeof jiti?.import !== "function") {
-            throw new Error("You are using an outdated version of the 'jiti' library. Please update to the latest version of 'jiti' to ensure compatibility and access to the latest features.");
-        }
-
-        const config = await jiti.import(fileURL.href);
-
-        importedConfigFileModificationTime.set(filePath, mtime);
-
-        return config?.default ?? config;
-    }
-
-    const config = (await import(fileURL.href)).default;
-
-    importedConfigFileModificationTime.set(filePath, mtime);
-
-    return config;
-}
 
 /**
  * Determines which config file to use. This is determined by seeing if an
  * override config file was passed, and if so, using it; otherwise, as long
  * as override config file is not explicitly set to `false`, it will search
  * upwards from the cwd for a file named `eslint.config.js`.
+ *
+ * This function is used primarily by the `--inspect-config` option. For now,
+ * we will maintain the existing behavior, which is to search up from the cwd.
  * @param {ESLintOptions} options The ESLint instance options.
- * @param {boolean} hasUnstableTSConfigFlag `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
- * @returns {Promise<{configFilePath:string|undefined;basePath:string;error:Error|null}>} Location information for
+ * @param {boolean} allowTS `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
+ * @returns {Promise<{configFilePath:string|undefined;basePath:string}>} Location information for
  *      the config file.
  */
-async function locateConfigFileToUse({ configFile, cwd }, hasUnstableTSConfigFlag) {
-
-    // determine where to load config file from
-    let configFilePath;
-    let basePath = cwd;
-    let error = null;
-
-    if (typeof configFile === "string") {
-        debug(`Override config file path is ${configFile}`);
-        configFilePath = path.resolve(cwd, configFile);
-    } else if (configFile !== false) {
-        debug("Searching for eslint.config.js");
-        configFilePath = await findFlatConfigFile(cwd, hasUnstableTSConfigFlag);
-
-        if (configFilePath) {
-            basePath = path.resolve(path.dirname(configFilePath));
-        } else {
-            error = new Error("Could not find config file.");
-            error.messageTemplate = "config-file-missing";
-        }
+async function locateConfigFileToUse({ configFile, cwd }, allowTS) {
+
+    const configLoader = new ConfigLoader({
+        cwd,
+        allowTS,
+        configFile
+    });
+
+    const configFilePath = await configLoader.findConfigFileForPath(path.join(cwd, "__placeholder__.js"));
 
+    if (!configFilePath) {
+        throw new Error("No ESLint configuration file was found.");
     }
 
     return {
         configFilePath,
-        basePath,
-        error
+        basePath: configFile ? cwd : path.dirname(configFilePath)
     };
-
-}
-
-/**
- * Calculates the config array for this run based on inputs.
- * @param {ESLint} eslint The instance to create the config array for.
- * @param {ESLintOptions} options The ESLint instance options.
- * @returns {Promise<typeof FlatConfigArray>} The config array for `eslint``.
- */
-async function calculateConfigArray(eslint, {
-    cwd,
-    baseConfig,
-    overrideConfig,
-    configFile,
-    ignore: shouldIgnore,
-    ignorePatterns
-}) {
-
-    // check for cached instance
-    const slots = privateMembers.get(eslint);
-
-    if (slots.configs) {
-        return slots.configs;
-    }
-
-    const hasUnstableTSConfigFlag = eslint.hasFlag("unstable_ts_config");
-
-    const { configFilePath, basePath, error } = await locateConfigFileToUse({ configFile, cwd }, hasUnstableTSConfigFlag);
-
-    // config file is required to calculate config
-    if (error) {
-        throw error;
-    }
-
-    const configs = new FlatConfigArray(baseConfig || [], { basePath, shouldIgnore });
-
-    // load config file
-    if (configFilePath) {
-        const fileConfig = await loadFlatConfigFile(configFilePath, hasUnstableTSConfigFlag);
-
-        if (Array.isArray(fileConfig)) {
-            configs.push(...fileConfig);
-        } else {
-            configs.push(fileConfig);
-        }
-    }
-
-    // add in any configured defaults
-    configs.push(...slots.defaultConfigs);
-
-    // append command line ignore patterns
-    if (ignorePatterns && ignorePatterns.length > 0) {
-
-        let relativeIgnorePatterns;
-
-        /*
-         * If the config file basePath is different than the cwd, then
-         * the ignore patterns won't work correctly. Here, we adjust the
-         * ignore pattern to include the correct relative path. Patterns
-         * passed as `ignorePatterns` are relative to the cwd, whereas
-         * the config file basePath can be an ancestor of the cwd.
-         */
-        if (basePath === cwd) {
-            relativeIgnorePatterns = ignorePatterns;
-        } else {
-
-            // In minimatch patterns, only `/` can be used as path separator
-            const relativeIgnorePath = path.relative(basePath, cwd).replaceAll(path.sep, "/");
-
-            relativeIgnorePatterns = ignorePatterns.map(pattern => {
-                const negated = pattern.startsWith("!");
-                const basePattern = negated ? pattern.slice(1) : pattern;
-
-                return (negated ? "!" : "") +
-                path.posix.join(relativeIgnorePath, basePattern);
-            });
-        }
-
-        /*
-         * Ignore patterns are added to the end of the config array
-         * so they can override default ignores.
-         */
-        configs.push({
-            ignores: relativeIgnorePatterns
-        });
-    }
-
-    if (overrideConfig) {
-        if (Array.isArray(overrideConfig)) {
-            configs.push(...overrideConfig);
-        } else {
-            configs.push(overrideConfig);
-        }
-    }
-
-    await configs.normalize();
-
-    // cache the config array for this instance
-    slots.configs = configs;
-
-    return configs;
 }
 
 /**
@@ -678,6 +431,12 @@ class ESLint {
      */
     static configType = "flat";
 
+    /**
+     * The loader to use for finding config files.
+     * @type {ConfigLoader|LegacyConfigLoader}
+     */
+    #configLoader;
+
     /**
      * Creates a new instance of the main ESLint API.
      * @param {ESLintOptions} options The options for this instance.
@@ -701,15 +460,34 @@ class ESLint {
             ? new LintResultCache(cacheFilePath, processedOptions.cacheStrategy)
             : null;
 
+        const configLoaderOptions = {
+            cwd: processedOptions.cwd,
+            baseConfig: processedOptions.baseConfig,
+            overrideConfig: processedOptions.overrideConfig,
+            configFile: processedOptions.configFile,
+            ignoreEnabled: processedOptions.ignore,
+            ignorePatterns: processedOptions.ignorePatterns,
+            defaultConfigs,
+            allowTS: processedOptions.flags.includes("unstable_ts_config")
+        };
+
+        this.#configLoader = processedOptions.flags.includes("unstable_config_lookup_from_file")
+            ? new ConfigLoader(configLoaderOptions)
+            : new LegacyConfigLoader(configLoaderOptions);
+
+        debug(`Using config loader ${this.#configLoader.constructor.name}`);
+
         privateMembers.set(this, {
             options: processedOptions,
             linter,
             cacheFilePath,
             lintResultCache,
             defaultConfigs,
-            configs: null
+            configs: null,
+            configLoader: this.#configLoader
         });
 
+
         /**
          * If additional plugins are passed in, add that to the default
          * configs for this instance.
@@ -813,20 +591,10 @@ class ESLint {
 
         const resultRules = new Map();
         const {
-            configs,
+            configLoader,
             options: { cwd }
         } = privateMembers.get(this);
 
-        /*
-         * We can only accurately return rules meta information for linting results if the
-         * results were created by this instance. Otherwise, the necessary rules data is
-         * not available. So if the config array doesn't already exist, just throw an error
-         * to let the user know we can't do anything here.
-         */
-        if (!configs) {
-            throw createExtraneousResultsError();
-        }
-
         for (const result of results) {
 
             /*
@@ -845,6 +613,14 @@ class ESLint {
                  * All of the plugin and rule information is contained within the
                  * calculated config for the given file.
                  */
+                let configs;
+
+                try {
+                    configs = configLoader.getCachedConfigArrayForFile(filePath);
+                } catch {
+                    throw createExtraneousResultsError();
+                }
+
                 const config = configs.getConfig(filePath);
 
                 if (!config) {
@@ -919,7 +695,6 @@ class ESLint {
 
         debug(`Using file patterns: ${normalizedPatterns}`);
 
-        const configs = await calculateConfigArray(this, eslintOptions);
         const {
             allowInlineConfig,
             cache,
@@ -955,7 +730,7 @@ class ESLint {
             patterns: normalizedPatterns,
             cwd,
             globInputPaths,
-            configs,
+            configLoader: this.#configLoader,
             errorOnUnmatchedPattern
         });
         const controller = new AbortController();
@@ -972,8 +747,9 @@ class ESLint {
          */
         const results = await Promise.all(
 
-            filePaths.map(filePath => {
+            filePaths.map(async filePath => {
 
+                const configs = await this.#configLoader.loadConfigArrayForFile(filePath);
                 const config = configs.getConfig(filePath);
 
                 /*
@@ -1111,7 +887,6 @@ class ESLint {
             linter,
             options: eslintOptions
         } = privateMembers.get(this);
-        const configs = await calculateConfigArray(this, eslintOptions);
         const {
             allowInlineConfig,
             cwd,
@@ -1125,21 +900,21 @@ class ESLint {
         const startTime = Date.now();
         const fixTypesSet = fixTypes ? new Set(fixTypes) : null;
         const resolvedFilename = path.resolve(cwd, filePath || "__placeholder__.js");
-        const config = configs.getConfig(resolvedFilename);
-
-        const fixer = getFixerForFixTypes(fix, fixTypesSet, config);
+        const configs = await this.#configLoader.loadConfigArrayForFile(resolvedFilename);
+        const configStatus = configs?.getConfigStatus(resolvedFilename) ?? "unconfigured";
 
         // Clear the last used config arrays.
-        if (resolvedFilename && await this.isPathIgnored(resolvedFilename)) {
+        if (resolvedFilename && configStatus !== "matched") {
             const shouldWarnIgnored = typeof warnIgnored === "boolean" ? warnIgnored : constructorWarnIgnored;
 
             if (shouldWarnIgnored) {
-                const configStatus = configs.getConfigStatus(resolvedFilename);
-
                 results.push(createIgnoreResult(resolvedFilename, cwd, configStatus));
             }
         } else {
 
+            const config = configs.getConfig(resolvedFilename);
+            const fixer = getFixerForFixTypes(fix, fixTypesSet, config);
+
             // Do lint.
             results.push(verifyText({
                 text: code,
@@ -1271,7 +1046,14 @@ class ESLint {
         }
         const options = privateMembers.get(this).options;
         const absolutePath = path.resolve(options.cwd, filePath);
-        const configs = await calculateConfigArray(this, options);
+        const configs = await this.#configLoader.loadConfigArrayForFile(absolutePath);
+
+        if (!configs) {
+            const error = new Error("Could not find config file.");
+
+            error.messageTemplate = "config-file-missing";
+            throw error;
+        }
 
         return configs.getConfig(absolutePath);
     }
@@ -1279,14 +1061,22 @@ class ESLint {
     /**
      * Finds the config file being used by this instance based on the options
      * passed to the constructor.
+     * @param {string} [filePath] The path of the file to find the config file for.
      * @returns {Promise<string|undefined>} The path to the config file being used or
      *      `undefined` if no config file is being used.
      */
-    async findConfigFile() {
+    findConfigFile(filePath) {
         const options = privateMembers.get(this).options;
-        const { configFilePath } = await locateConfigFileToUse(options, this.hasFlag("unstable_ts_config"));
 
-        return configFilePath;
+        /*
+         * Because the new config lookup scheme skips the current directory
+         * and looks into the parent directories, we need to use a placeholder
+         * directory to ensure the file in cwd is checked.
+         */
+        const fakeCwd = path.join(options.cwd, "__placeholder__");
+
+        return this.#configLoader.findConfigFileForPath(filePath ?? fakeCwd)
+            .catch(() => void 0);
     }
 
     /**

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

@@ -47,6 +47,8 @@ const { SourceCode } = require("../languages/js/source-code");
  * @property {string} [name] Name for the test case.
  * @property {string} code Code for the test case.
  * @property {any[]} [options] Options for the test case.
+ * @property {Function} [before] Function to execute before testing the case.
+ * @property {Function} [after] Function to execute after testing the case regardless of its result.
  * @property {LanguageOptions} [languageOptions] The language options to use in the test case.
  * @property {{ [name: string]: any }} [settings] Settings for the test case.
  * @property {string} [filename] The fake filename for the test case. Useful for rules that make assertion about filenames.
@@ -61,6 +63,8 @@ const { SourceCode } = require("../languages/js/source-code");
  * @property {number | Array<TestCaseError | string | RegExp>} errors Expected errors.
  * @property {string | null} [output] The expected code after autofixes are applied. If set to `null`, the test runner will assert that no autofix is suggested.
  * @property {any[]} [options] Options for the test case.
+ * @property {Function} [before] Function to execute before testing the case.
+ * @property {Function} [after] Function to execute after testing the case regardless of its result.
  * @property {{ [name: string]: any }} [settings] Settings for the test case.
  * @property {string} [filename] The fake filename for the test case. Useful for rules that make assertion about filenames.
  * @property {LanguageOptions} [languageOptions] The language options to use in the test case.
@@ -105,6 +109,8 @@ const RuleTesterParameters = [
     "code",
     "filename",
     "options",
+    "before",
+    "after",
     "errors",
     "output",
     "only"
@@ -621,6 +627,21 @@ class RuleTester {
             ...defaultConfig.slice(1)
         ];
 
+        /**
+         * Runs a hook on the given item when it's assigned to the given property
+         * @param {string|Object} item Item to run the hook on
+         * @param {string} prop The property having the hook assigned to
+         * @throws {Error} If the property is not a function or that function throws an error
+         * @returns {void}
+         * @private
+         */
+        function runHook(item, prop) {
+            if (typeof item === "object" && hasOwnProperty(item, prop)) {
+                assert.strictEqual(typeof item[prop], "function", `Optional test case property '${prop}' must be a function`);
+                item[prop]();
+            }
+        }
+
         /**
          * Run the rule for the given item
          * @param {string|Object} item Item to run the rule against
@@ -1258,7 +1279,12 @@ class RuleTester {
                         this.constructor[valid.only ? "itOnly" : "it"](
                             sanitize(typeof valid === "object" ? valid.name || valid.code : valid),
                             () => {
-                                testValidTemplate(valid);
+                                try {
+                                    runHook(valid, "before");
+                                    testValidTemplate(valid);
+                                } finally {
+                                    runHook(valid, "after");
+                                }
                             }
                         );
                     });
@@ -1271,7 +1297,12 @@ class RuleTester {
                         this.constructor[invalid.only ? "itOnly" : "it"](
                             sanitize(invalid.name || invalid.code),
                             () => {
-                                testInvalidTemplate(invalid);
+                                try {
+                                    runHook(invalid, "before");
+                                    testInvalidTemplate(invalid);
+                                } finally {
+                                    runHook(invalid, "after");
+                                }
                             }
                         );
                     });

package/lib/rules/complexity.js

@@ -45,6 +45,9 @@ module.exports = {
                             max: {
                                 type: "integer",
                                 minimum: 0
+                            },
+                            variant: {
+                                enum: ["classic", "modified"]
                             }
                         },
                         additionalProperties: false
@@ -61,16 +64,22 @@ module.exports = {
     create(context) {
         const option = context.options[0];
         let THRESHOLD = 20;
+        let VARIANT = "classic";
+
+        if (typeof option === "object") {
+            if (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max")) {
+                THRESHOLD = option.maximum || option.max;
+            }
 
-        if (
-            typeof option === "object" &&
-            (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max"))
-        ) {
-            THRESHOLD = option.maximum || option.max;
+            if (Object.hasOwn(option, "variant")) {
+                VARIANT = option.variant;
+            }
         } else if (typeof option === "number") {
             THRESHOLD = option;
         }
 
+        const IS_MODIFIED_COMPLEXITY = VARIANT === "modified";
+
         //--------------------------------------------------------------------------
         // Helpers
         //--------------------------------------------------------------------------
@@ -112,7 +121,8 @@ module.exports = {
             AssignmentPattern: increaseComplexity,
 
             // Avoid `default`
-            "SwitchCase[test]": increaseComplexity,
+            "SwitchCase[test]": () => IS_MODIFIED_COMPLEXITY || increaseComplexity(),
+            SwitchStatement: () => IS_MODIFIED_COMPLEXITY && increaseComplexity(),
 
             // Logical assignment operators have short-circuiting behavior
             AssignmentExpression(node) {

package/lib/shared/flags.js

@@ -10,6 +10,7 @@
  */
 const activeFlags = new Map([
     ["test_only", "Used only for testing."],
+    ["unstable_config_lookup_from_file", "Look up eslint.config.js from the file being linted."],
     ["unstable_ts_config", "Enable TypeScript configuration files."]
 ]);