eslint 8.21.0 → 8.23.1

package/bin/eslint.js

@@ -9,9 +9,6 @@
 
 "use strict";
 
-// to use V8's code cache to speed up instantiation time
-require("v8-compile-cache");
-
 // must do this initialization *before* other requires in order to work
 if (process.argv.includes("--debug")) {
     require("debug").enable("eslint:*,-eslint:code-path,eslintrc:*");
@@ -137,6 +134,7 @@ ${message}`);
     // Otherwise, call the CLI.
     process.exitCode = await require("../lib/cli").execute(
         process.argv,
-        process.argv.includes("--stdin") ? await readStdin() : null
+        process.argv.includes("--stdin") ? await readStdin() : null,
+        true
     );
 }()).catch(onFatalError);

package/conf/globals.js

@@ -124,6 +124,10 @@ const es2022 = {
     ...es2021
 };
 
+const es2023 = {
+    ...es2022
+};
+
 
 //-----------------------------------------------------------------------------
 // Exports
@@ -140,5 +144,6 @@ module.exports = {
     es2019,
     es2020,
     es2021,
-    es2022
+    es2022,
+    es2023
 };

package/lib/cli-engine/file-enumerator.js

@@ -122,7 +122,8 @@ function statSafeSync(filePath) {
     try {
         return fs.statSync(filePath);
     } catch (error) {
-        /* istanbul ignore next */
+
+        /* c8 ignore next */
         if (error.code !== "ENOENT") {
             throw error;
         }
@@ -141,7 +142,8 @@ function readdirSafeSync(directoryPath) {
     try {
         return fs.readdirSync(directoryPath, { withFileTypes: true });
     } catch (error) {
-        /* istanbul ignore next */
+
+        /* c8 ignore next */
         if (error.code !== "ENOENT") {
             throw error;
         }

package/lib/cli.js

@@ -6,7 +6,7 @@
 "use strict";
 
 /*
- * The CLI object should *not* call process.exit() directly. It should only return
+ * NOTE: The CLI object should *not* call process.exit() directly. It should only return
  * exit codes. This allows other programs to use the CLI object and still control
  * when the program exits.
  */
@@ -19,9 +19,14 @@ const fs = require("fs"),
     path = require("path"),
     { promisify } = require("util"),
     { ESLint } = require("./eslint"),
-    CLIOptions = require("./options"),
+    { FlatESLint } = require("./eslint/flat-eslint"),
+    createCLIOptions = require("./options"),
     log = require("./shared/logging"),
     RuntimeInfo = require("./shared/runtime-info");
+const { Legacy: { naming } } = require("@eslint/eslintrc");
+const { findFlatConfigFile } = require("./eslint/flat-eslint");
+const { gitignoreToMinimatch } = require("@humanwhocodes/gitignore-to-minimatch");
+const { ModuleImporter } = require("@humanwhocodes/module-importer");
 
 const debug = require("debug")("eslint:cli");
 
@@ -54,17 +59,20 @@ function quietFixPredicate(message) {
 }
 
 /**
- * Translates the CLI options into the options expected by the CLIEngine.
+ * Translates the CLI options into the options expected by the ESLint constructor.
  * @param {ParsedCLIOptions} cliOptions The CLI options to translate.
- * @returns {ESLintOptions} The options object for the CLIEngine.
+ * @param {"flat"|"eslintrc"} [configType="eslintrc"] The format of the
+ *      config to generate.
+ * @returns {Promise<ESLintOptions>} The options object for the ESLint constructor.
  * @private
  */
-function translateOptions({
+async function translateOptions({
     cache,
     cacheFile,
     cacheLocation,
     cacheStrategy,
     config,
+    configLookup,
     env,
     errorOnUnmatchedPattern,
     eslintrc,
@@ -85,19 +93,66 @@ function translateOptions({
     resolvePluginsRelativeTo,
     rule,
     rulesdir
-}) {
-    return {
-        allowInlineConfig: inlineConfig,
-        cache,
-        cacheLocation: cacheLocation || cacheFile,
-        cacheStrategy,
-        errorOnUnmatchedPattern,
-        extensions: ext,
-        fix: (fix || fixDryRun) && (quiet ? quietFixPredicate : true),
-        fixTypes: fixType,
-        ignore,
-        ignorePath,
-        overrideConfig: {
+}, configType) {
+
+    let overrideConfig, overrideConfigFile;
+    const importer = new ModuleImporter();
+
+    if (configType === "flat") {
+        overrideConfigFile = (typeof config === "string") ? config : !configLookup;
+        if (overrideConfigFile === false) {
+            overrideConfigFile = void 0;
+        }
+
+        let globals = {};
+
+        if (global) {
+            globals = global.reduce((obj, name) => {
+                if (name.endsWith(":true")) {
+                    obj[name.slice(0, -5)] = "writable";
+                } else {
+                    obj[name] = "readonly";
+                }
+                return obj;
+            }, globals);
+        }
+
+        overrideConfig = [{
+            languageOptions: {
+                globals,
+                parserOptions: parserOptions || {}
+            },
+            rules: rule ? rule : {}
+        }];
+
+        if (parser) {
+            overrideConfig[0].languageOptions.parser = await importer.import(parser);
+        }
+
+        if (plugin) {
+            const plugins = {};
+
+            for (const pluginName of plugin) {
+
+                const shortName = naming.getShorthandName(pluginName, "eslint-plugin");
+                const longName = naming.normalizePackageName(pluginName, "eslint-plugin");
+
+                plugins[shortName] = await importer.import(longName);
+            }
+
+            overrideConfig[0].plugins = plugins;
+        }
+
+        if (ignorePattern) {
+            overrideConfig.push({
+                ignores: ignorePattern.map(gitignoreToMinimatch)
+            });
+        }
+
+    } else {
+        overrideConfigFile = config;
+
+        overrideConfig = {
             env: env && env.reduce((obj, name) => {
                 obj[name] = true;
                 return obj;
@@ -115,13 +170,32 @@ function translateOptions({
             parserOptions,
             plugins: plugin,
             rules: rule
-        },
-        overrideConfigFile: config,
-        reportUnusedDisableDirectives: reportUnusedDisableDirectives ? "error" : void 0,
-        resolvePluginsRelativeTo,
-        rulePaths: rulesdir,
-        useEslintrc: eslintrc
+        };
+    }
+
+    const options = {
+        allowInlineConfig: inlineConfig,
+        cache,
+        cacheLocation: cacheLocation || cacheFile,
+        cacheStrategy,
+        errorOnUnmatchedPattern,
+        fix: (fix || fixDryRun) && (quiet ? quietFixPredicate : true),
+        fixTypes: fixType,
+        ignore,
+        ignorePath,
+        overrideConfig,
+        overrideConfigFile,
+        reportUnusedDisableDirectives: reportUnusedDisableDirectives ? "error" : void 0
     };
+
+    if (configType !== "flat") {
+        options.resolvePluginsRelativeTo = resolvePluginsRelativeTo;
+        options.rulePaths = rulesdir;
+        options.useEslintrc = eslintrc;
+        options.extensions = ext;
+    }
+
+    return options;
 }
 
 /**
@@ -218,19 +292,34 @@ const cli = {
      * Executes the CLI based on an array of arguments that is passed in.
      * @param {string|Array|Object} args The arguments to process.
      * @param {string} [text] The text to lint (used for TTY).
+     * @param {boolean} [allowFlatConfig] Whether or not to allow flat config.
      * @returns {Promise<number>} The exit code for the operation.
      */
-    async execute(args, text) {
+    async execute(args, text, allowFlatConfig) {
         if (Array.isArray(args)) {
             debug("CLI args: %o", args.slice(2));
         }
 
+        /*
+         * Before doing anything, we need to see if we are using a
+         * flat config file. If so, then we need to change the way command
+         * line args are parsed. This is temporary, and when we fully
+         * switch to flat config we can remove this logic.
+         */
+
+        const usingFlatConfig = allowFlatConfig && !!(await findFlatConfigFile(process.cwd()));
+
+        debug("Using flat config?", usingFlatConfig);
+
+        const CLIOptions = createCLIOptions(usingFlatConfig);
+
         /** @type {ParsedCLIOptions} */
         let options;
 
         try {
             options = CLIOptions.parse(args);
         } catch (error) {
+            debug("Error parsing CLI options:", error.message);
             log.error(error.message);
             return 2;
         }
@@ -251,6 +340,7 @@ const cli = {
                 log.info(RuntimeInfo.environment());
                 return 0;
             } catch (err) {
+                debug("Error retrieving environment info");
                 log.error(err.message);
                 return 2;
             }
@@ -266,7 +356,9 @@ const cli = {
                 return 2;
             }
 
-            const engine = new ESLint(translateOptions(options));
+            const engine = usingFlatConfig
+                ? new FlatESLint(await translateOptions(options, "flat"))
+                : new ESLint(await translateOptions(options));
             const fileConfig =
                 await engine.calculateConfigForFile(options.printConfig);
 
@@ -289,7 +381,9 @@ const cli = {
             return 2;
         }
 
-        const engine = new ESLint(translateOptions(options));
+        const ActiveESLint = usingFlatConfig ? FlatESLint : ESLint;
+
+        const engine = new ActiveESLint(await translateOptions(options, usingFlatConfig ? "flat" : "eslintrc"));
         let results;
 
         if (useStdin) {
@@ -303,14 +397,14 @@ const cli = {
 
         if (options.fix) {
             debug("Fix mode enabled - applying fixes");
-            await ESLint.outputFixes(results);
+            await ActiveESLint.outputFixes(results);
         }
 
         let resultsToPrint = results;
 
         if (options.quiet) {
             debug("Quiet mode enabled - filtering out warnings");
-            resultsToPrint = ESLint.getErrorResults(resultsToPrint);
+            resultsToPrint = ActiveESLint.getErrorResults(resultsToPrint);
         }
 
         if (await printResults(engine, resultsToPrint, options.format, options.outputFile)) {

package/lib/config/flat-config-array.js

@@ -139,31 +139,72 @@ class FlatConfigArray extends ConfigArray {
     [ConfigArraySymbol.finalizeConfig](config) {
 
         const { plugins, languageOptions, processor } = config;
+        let parserName, processorName;
+        let invalidParser = false,
+            invalidProcessor = false;
 
         // Check parser value
-        if (languageOptions && languageOptions.parser && typeof languageOptions.parser === "string") {
-            const { pluginName, objectName: parserName } = splitPluginIdentifier(languageOptions.parser);
+        if (languageOptions && languageOptions.parser) {
+            if (typeof languageOptions.parser === "string") {
+                const { pluginName, objectName: localParserName } = splitPluginIdentifier(languageOptions.parser);
 
-            if (!plugins || !plugins[pluginName] || !plugins[pluginName].parsers || !plugins[pluginName].parsers[parserName]) {
-                throw new TypeError(`Key "parser": Could not find "${parserName}" in plugin "${pluginName}".`);
-            }
+                parserName = languageOptions.parser;
+
+                if (!plugins || !plugins[pluginName] || !plugins[pluginName].parsers || !plugins[pluginName].parsers[localParserName]) {
+                    throw new TypeError(`Key "parser": Could not find "${localParserName}" in plugin "${pluginName}".`);
+                }
 
-            languageOptions.parser = plugins[pluginName].parsers[parserName];
+                languageOptions.parser = plugins[pluginName].parsers[localParserName];
+            } else {
+                invalidParser = true;
+            }
         }
 
         // Check processor value
-        if (processor && typeof processor === "string") {
-            const { pluginName, objectName: processorName } = splitPluginIdentifier(processor);
+        if (processor) {
+            if (typeof processor === "string") {
+                const { pluginName, objectName: localProcessorName } = splitPluginIdentifier(processor);
 
-            if (!plugins || !plugins[pluginName] || !plugins[pluginName].processors || !plugins[pluginName].processors[processorName]) {
-                throw new TypeError(`Key "processor": Could not find "${processorName}" in plugin "${pluginName}".`);
-            }
+                processorName = processor;
+
+                if (!plugins || !plugins[pluginName] || !plugins[pluginName].processors || !plugins[pluginName].processors[localProcessorName]) {
+                    throw new TypeError(`Key "processor": Could not find "${localProcessorName}" in plugin "${pluginName}".`);
+                }
 
-            config.processor = plugins[pluginName].processors[processorName];
+                config.processor = plugins[pluginName].processors[localProcessorName];
+            } else {
+                invalidProcessor = true;
+            }
         }
 
         ruleValidator.validate(config);
 
+        // apply special logic for serialization into JSON
+        /* eslint-disable object-shorthand -- shorthand would change "this" value */
+        Object.defineProperty(config, "toJSON", {
+            value: function() {
+
+                if (invalidParser) {
+                    throw new Error("Caching is not supported when parser is an object.");
+                }
+
+                if (invalidProcessor) {
+                    throw new Error("Caching is not supported when processor is an object.");
+                }
+
+                return {
+                    ...this,
+                    plugins: Object.keys(plugins),
+                    languageOptions: {
+                        ...languageOptions,
+                        parser: parserName
+                    },
+                    processor: processorName
+                };
+            }
+        });
+        /* eslint-enable object-shorthand -- ok to enable now */
+
         return config;
     }
     /* eslint-enable class-methods-use-this -- Desired as instance method */

package/lib/eslint/eslint-helpers.js

@@ -15,6 +15,7 @@ const fsp = fs.promises;
 const isGlob = require("is-glob");
 const globby = require("globby");
 const hash = require("../cli-engine/hash");
+const minimatch = require("minimatch");
 
 //-----------------------------------------------------------------------------
 // Errors
@@ -104,6 +105,8 @@ function isGlobPattern(pattern) {
  *      false to not interpret glob patterns.
  * @param {string} args.cwd The current working directory to find from.
  * @param {FlatConfigArray} args.configs The configs for the current run.
+ * @param {boolean} args.errorOnUnmatchedPattern Determines if an unmatched pattern
+ *      should throw an error.
  * @returns {Promise<Array<string>>} The fully resolved file paths.
  * @throws {AllFilesIgnoredError} If there are no results due to an ignore pattern.
  * @throws {NoFilesFoundError} If no files matched the given patterns.
@@ -112,7 +115,8 @@ async function findFiles({
     patterns,
     globInputPaths,
     cwd,
-    configs
+    configs,
+    errorOnUnmatchedPattern
 }) {
 
     const results = [];
@@ -123,14 +127,14 @@ async function findFiles({
     const filePaths = patterns.map(filePath => path.resolve(cwd, filePath));
     const stats = await Promise.all(
         filePaths.map(
-            filePath => fsp.stat(filePath).catch(() => {})
+            filePath => fsp.stat(filePath).catch(() => { })
         )
     );
 
     stats.forEach((stat, index) => {
 
         const filePath = filePaths[index];
-        const pattern = patterns[index];
+        const pattern = normalizeToPosix(patterns[index]);
 
         if (stat) {
 
@@ -154,6 +158,11 @@ async function findFiles({
                             return false;
                         }
 
+                        // patterns starting with ** always apply
+                        if (filePattern.startsWith("**")) {
+                            return true;
+                        }
+
                         // patterns ending with * are not used for file search
                         if (filePattern.endsWith("*")) {
                             return false;
@@ -164,11 +173,27 @@ async function findFiles({
                             return false;
                         }
 
-                        // check if the pattern would be inside the cwd or not
+                        // check if the pattern would be inside the config base path or not
                         const fullFilePattern = path.join(cwd, filePattern);
-                        const relativeFilePattern = path.relative(configs.basePath, fullFilePattern);
+                        const patternRelativeToConfigBasePath = path.relative(configs.basePath, fullFilePattern);
+
+                        if (patternRelativeToConfigBasePath.startsWith("..")) {
+                            return false;
+                        }
+
+                        // check if the pattern matches
+                        if (minimatch(filePath, path.dirname(fullFilePattern), { partial: true })) {
+                            return true;
+                        }
 
-                        return !relativeFilePattern.startsWith("..");
+                        // check if the pattern is inside the directory or not
+                        const patternRelativeToFilePath = path.relative(filePath, fullFilePattern);
+
+                        if (patternRelativeToFilePath.startsWith("..")) {
+                            return false;
+                        }
+
+                        return true;
                     })
                     .map(filePattern => {
                         if (filePattern.startsWith("**")) {
@@ -222,14 +247,16 @@ async function findFiles({
             }
 
             // no files were found
-            throw new NoFilesFoundError(globbyPattern, globInputPaths);
+            if (errorOnUnmatchedPattern) {
+                throw new NoFilesFoundError(globbyPattern, globInputPaths);
+            }
         }
         /* eslint-enable no-unreachable-loop -- Go back to normal. */
 
     }
 
     // there were patterns that didn't match anything, tell the user
-    if (missingPatterns.length) {
+    if (errorOnUnmatchedPattern && missingPatterns.length) {
         throw new NoFilesFoundError(missingPatterns[0], globInputPaths);
     }
 
@@ -322,6 +349,7 @@ function createIgnoreResult(filePath, baseDir) {
                 message
             }
         ],
+        suppressedMessages: [],
         errorCount: 0,
         warningCount: 1,
         fatalErrorCount: 0,
@@ -378,7 +406,6 @@ function processOptions({
     cacheStrategy = "metadata",
     cwd = process.cwd(),
     errorOnUnmatchedPattern = true,
-    extensions = null, // ← should be null by default because if it's an array then it suppresses RFC20 feature.
     fix = false,
     fixTypes = null, // ← should be null by default because if it's an array then it suppresses rules that don't have the `meta.type` property.
     globInputPaths = true,
@@ -405,6 +432,9 @@ function processOptions({
         if (unknownOptionKeys.includes("envs")) {
             errors.push("'envs' has been removed.");
         }
+        if (unknownOptionKeys.includes("extensions")) {
+            errors.push("'extensions' has been removed.");
+        }
         if (unknownOptionKeys.includes("resolvePluginsRelativeTo")) {
             errors.push("'resolvePluginsRelativeTo' has been removed.");
         }
@@ -436,9 +466,6 @@ function processOptions({
     if (typeof cache !== "boolean") {
         errors.push("'cache' must be a boolean.");
     }
-    if (cache) {
-        errors.push("'cache' option is not yet supported.");
-    }
     if (!isNonEmptyString(cacheLocation)) {
         errors.push("'cacheLocation' must be a non-empty string.");
     }
@@ -454,9 +481,6 @@ function processOptions({
     if (typeof errorOnUnmatchedPattern !== "boolean") {
         errors.push("'errorOnUnmatchedPattern' must be a boolean.");
     }
-    if (!isArrayOfNonEmptyString(extensions) && extensions !== null) {
-        errors.push("'extensions' must be an array of non-empty strings or null.");
-    }
     if (typeof fix !== "boolean" && typeof fix !== "function") {
         errors.push("'fix' must be a boolean or a function.");
     }
@@ -510,7 +534,6 @@ function processOptions({
         overrideConfig,
         cwd,
         errorOnUnmatchedPattern,
-        extensions,
         fix,
         fixTypes,
         globInputPaths,