eslint 8.20.0 → 8.23.0

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.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/default-config.js

@@ -15,7 +15,6 @@ const Rules = require("../rules");
 // Helpers
 //-----------------------------------------------------------------------------
 
-
 exports.defaultConfig = [
     {
         plugins: {
@@ -41,21 +40,31 @@ exports.defaultConfig = [
                 })
             }
         },
-        ignores: [
-            "**/node_modules/**",
-            ".git/**"
-        ],
         languageOptions: {
-            ecmaVersion: "latest",
             sourceType: "module",
+            ecmaVersion: "latest",
             parser: "@/espree",
             parserOptions: {}
         }
     },
+
+    // default ignores are listed here
+    {
+        ignores: [
+            "**/node_modules/**",
+            ".git/**"
+        ]
+    },
+
+    // intentionally empty config to ensure these files are globbed by default
+    {
+        files: ["**/*.js", "**/*.mjs"]
+    },
     {
         files: ["**/*.cjs"],
         languageOptions: {
-            sourceType: "commonjs"
+            sourceType: "commonjs",
+            ecmaVersion: "latest"
         }
     }
 ];

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

@@ -36,6 +36,8 @@ function splitPluginIdentifier(identifier) {
     };
 }
 
+const originalBaseConfig = Symbol("originalBaseConfig");
+
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
@@ -48,10 +50,14 @@ class FlatConfigArray extends ConfigArray {
     /**
      * Creates a new instance.
      * @param {*[]} configs An array of configuration information.
-     * @param {{basePath: string, baseConfig: FlatConfig}} options The options
+     * @param {{basePath: string, shouldIgnore: boolean, baseConfig: FlatConfig}} options The options
      *      to use for the config array instance.
      */
-    constructor(configs, { basePath, baseConfig = defaultConfig } = {}) {
+    constructor(configs, {
+        basePath,
+        shouldIgnore = true,
+        baseConfig = defaultConfig
+    } = {}) {
         super(configs, {
             basePath,
             schema: flatConfigSchema
@@ -62,6 +68,22 @@ class FlatConfigArray extends ConfigArray {
         } else {
             this.unshift(baseConfig);
         }
+
+        /**
+         * The baes config used to build the config array.
+         * @type {Array<FlatConfig>}
+         */
+        this[originalBaseConfig] = baseConfig;
+        Object.defineProperty(this, originalBaseConfig, { writable: false });
+
+        /**
+         * Determines if `ignores` fields should be honored.
+         * If true, then all `ignores` fields are honored.
+         * if false, then only `ignores` fields in the baseConfig are honored.
+         * @type {boolean}
+         */
+        this.shouldIgnore = shouldIgnore;
+        Object.defineProperty(this, "shouldIgnore", { writable: false });
     }
 
     /* eslint-disable class-methods-use-this -- Desired as instance method */
@@ -87,6 +109,23 @@ class FlatConfigArray extends ConfigArray {
             return require("../../conf/eslint-all");
         }
 
+        /*
+         * If `shouldIgnore` is false, we remove any ignore patterns specified
+         * in the config so long as it's not a default config and it doesn't
+         * have a `files` entry.
+         */
+        if (
+            !this.shouldIgnore &&
+            !this[originalBaseConfig].includes(config) &&
+            config.ignores &&
+            !config.files
+        ) {
+            /* eslint-disable-next-line no-unused-vars -- need to strip off other keys */
+            const { ignores, ...otherKeys } = config;
+
+            return otherKeys;
+        }
+
         return config;
     }
 
@@ -100,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/config/flat-config-helpers.js

@@ -20,7 +20,14 @@ function parseRuleId(ruleId) {
 
     // distinguish between core rules and plugin rules
     if (ruleId.includes("/")) {
-        pluginName = ruleId.slice(0, ruleId.lastIndexOf("/"));
+
+        // mimic scoped npm packages
+        if (ruleId.startsWith("@")) {
+            pluginName = ruleId.slice(0, ruleId.lastIndexOf("/"));
+        } else {
+            pluginName = ruleId.slice(0, ruleId.indexOf("/"));
+        }
+
         ruleName = ruleId.slice(pluginName.length + 1);
     } else {
         pluginName = "@";
@@ -47,6 +54,7 @@ function getRuleFromConfig(ruleId, config) {
     const plugin = config.plugins && config.plugins[pluginName];
     let rule = plugin && plugin.rules && plugin.rules[ruleName];
 
+
     // normalize function rules into objects
     if (rule && typeof rule === "function") {
         rule = {