eslint 8.39.0 → 8.47.0

package/lib/eslint/flat-eslint.js

@@ -55,6 +55,7 @@ const LintResultCache = require("../cli-engine/lint-result-cache");
 /** @typedef {import("../shared/types").ConfigData} ConfigData */
 /** @typedef {import("../shared/types").DeprecatedRuleInfo} DeprecatedRuleInfo */
 /** @typedef {import("../shared/types").LintMessage} LintMessage */
+/** @typedef {import("../shared/types").LintResult} LintResult */
 /** @typedef {import("../shared/types").ParserOptions} ParserOptions */
 /** @typedef {import("../shared/types").Plugin} Plugin */
 /** @typedef {import("../shared/types").ResultsMeta} ResultsMeta */
@@ -76,7 +77,7 @@ const LintResultCache = require("../cli-engine/lint-result-cache");
  * @property {string[]} [fixTypes] Array of rule types to apply fixes for.
  * @property {boolean} [globInputPaths] Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
  * @property {boolean} [ignore] False disables all ignore patterns except for the default ones.
- * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to config ignores.
+ * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to config ignores. These patterns are relative to `cwd`.
  * @property {ConfigData} [overrideConfig] Override config object, overrides all configs used with this instance
  * @property {boolean|string} [overrideConfigFile] Searches for default config file when falsy;
  *      doesn't do any config file lookup when `true`; considered to be a config filename
@@ -102,7 +103,17 @@ const importedConfigFileModificationTime = new Map();
  * @private
  */
 function calculateStatsPerFile(messages) {
-    return messages.reduce((stat, message) => {
+    const stat = {
+        errorCount: 0,
+        fatalErrorCount: 0,
+        warningCount: 0,
+        fixableErrorCount: 0,
+        fixableWarningCount: 0
+    };
+
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+
         if (message.fatal || message.severity === 2) {
             stat.errorCount++;
             if (message.fatal) {
@@ -117,37 +128,8 @@ function calculateStatsPerFile(messages) {
                 stat.fixableWarningCount++;
             }
         }
-        return stat;
-    }, {
-        errorCount: 0,
-        fatalErrorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-    });
-}
-
-/**
- * It will calculate the error and warning count for collection of results from all files
- * @param {LintResult[]} results Collection of messages from all the files
- * @returns {Object} Contains the stats
- * @private
- */
-function calculateStatsPerRun(results) {
-    return results.reduce((stat, result) => {
-        stat.errorCount += result.errorCount;
-        stat.fatalErrorCount += result.fatalErrorCount;
-        stat.warningCount += result.warningCount;
-        stat.fixableErrorCount += result.fixableErrorCount;
-        stat.fixableWarningCount += result.fixableWarningCount;
-        return stat;
-    }, {
-        errorCount: 0,
-        fatalErrorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-    });
+    }
+    return stat;
 }
 
 /**
@@ -261,7 +243,7 @@ function compareResultsByFilePath(a, b) {
  * Searches from the current working directory up until finding the
  * given flat config filename.
  * @param {string} cwd The current working directory to search from.
- * @returns {Promise<string|null>} The filename if found or `null` if not.
+ * @returns {Promise<string|undefined>} The filename if found or `undefined` if not.
  */
 function findFlatConfigFile(cwd) {
     return findUp(
@@ -320,6 +302,45 @@ async function loadFlatConfigFile(filePath) {
     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`.
+ * @param {import("./eslint").ESLintOptions} options The ESLint instance options.
+ * @returns {{configFilePath:string|undefined,basePath:string,error:Error|null}} Location information for
+ *      the config file.
+ */
+async function locateConfigFileToUse({ configFile, cwd }) {
+
+    // 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);
+
+        if (configFilePath) {
+            basePath = path.resolve(path.dirname(configFilePath));
+        } else {
+            error = new Error("Could not find config file.");
+        }
+
+    }
+
+    return {
+        configFilePath,
+        basePath,
+        error
+    };
+
+}
+
 /**
  * Calculates the config array for this run based on inputs.
  * @param {FlatESLint} eslint The instance to create the config array for.
@@ -342,25 +363,13 @@ async function calculateConfigArray(eslint, {
         return slots.configs;
     }
 
-    // determine where to load config file from
-    let configFilePath;
-    let basePath = cwd;
-
-    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);
-
-        if (!configFilePath) {
-            throw new Error("Could not find config file.");
-        }
+    const { configFilePath, basePath, error } = await locateConfigFileToUse({ configFile, cwd });
 
-        basePath = path.resolve(path.dirname(configFilePath));
+    // config file is required to calculate config
+    if (error) {
+        throw error;
     }
 
-
     const configs = new FlatConfigArray(baseConfig || [], { basePath, shouldIgnore });
 
     // load config file
@@ -377,45 +386,39 @@ async function calculateConfigArray(eslint, {
     // add in any configured defaults
     configs.push(...slots.defaultConfigs);
 
-    let allIgnorePatterns = [];
-
     // append command line ignore patterns
-    if (ignorePatterns) {
-        if (typeof ignorePatterns === "string") {
-            allIgnorePatterns.push(ignorePatterns);
-        } else {
-            allIgnorePatterns.push(...ignorePatterns);
-        }
-    }
+    if (ignorePatterns && ignorePatterns.length > 0) {
 
-    /*
-     * 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
-     * loaded from ignore files are always relative to the cwd, whereas
-     * the config file basePath can be an ancestor of the cwd.
-     */
-    if (basePath !== cwd && allIgnorePatterns.length) {
+        let relativeIgnorePatterns;
 
-        const relativeIgnorePath = path.relative(basePath, cwd);
+        /*
+         * 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 {
 
-        allIgnorePatterns = allIgnorePatterns.map(pattern => {
-            const negated = pattern.startsWith("!");
-            const basePattern = negated ? pattern.slice(1) : pattern;
+            const relativeIgnorePath = path.relative(basePath, cwd);
 
-            return (negated ? "!" : "") +
-                path.posix.join(relativeIgnorePath, basePattern);
-        });
-    }
+            relativeIgnorePatterns = ignorePatterns.map(pattern => {
+                const negated = pattern.startsWith("!");
+                const basePattern = negated ? pattern.slice(1) : pattern;
 
-    if (allIgnorePatterns.length) {
+                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: allIgnorePatterns
+            ignores: relativeIgnorePatterns
         });
     }
 
@@ -528,43 +531,6 @@ function shouldMessageBeFixed(message, config, fixTypes) {
     return Boolean(rule && rule.meta && fixTypes.has(rule.meta.type));
 }
 
-/**
- * Collect used deprecated rules.
- * @param {Array<FlatConfig>} configs The configs to evaluate.
- * @returns {IterableIterator<DeprecatedRuleInfo>} Used deprecated rules.
- */
-function *iterateRuleDeprecationWarnings(configs) {
-    const processedRuleIds = new Set();
-
-    for (const config of configs) {
-        for (const [ruleId, ruleConfig] of Object.entries(config.rules)) {
-
-            // Skip if it was processed.
-            if (processedRuleIds.has(ruleId)) {
-                continue;
-            }
-            processedRuleIds.add(ruleId);
-
-            // Skip if it's not used.
-            if (!getRuleSeverity(ruleConfig)) {
-                continue;
-            }
-            const rule = getRuleFromConfig(ruleId, config);
-
-            // Skip if it's not deprecated.
-            if (!(rule && rule.meta && rule.meta.deprecated)) {
-                continue;
-            }
-
-            // This rule was used and deprecated.
-            yield {
-                ruleId,
-                replacedBy: rule.meta.replacedBy || []
-            };
-        }
-    }
-}
-
 /**
  * Creates an error to be thrown when an array of results passed to `getRulesMetaForResults` was not created by the current engine.
  * @returns {TypeError} An error object.
@@ -610,7 +576,6 @@ class FlatESLint {
             cacheFilePath,
             lintResultCache,
             defaultConfigs,
-            defaultIgnores: () => false,
             configs: null
         });
 
@@ -749,12 +714,10 @@ class FlatESLint {
                 }
                 const rule = getRuleFromConfig(ruleId, config);
 
-                // ensure the rule exists
-                if (!rule) {
-                    throw new TypeError(`Could not find the rule "${ruleId}".`);
+                // ignore unknown rules
+                if (rule) {
+                    resultRules.set(ruleId, rule);
                 }
-
-                resultRules.set(ruleId, rule);
             }
         }
 
@@ -789,7 +752,6 @@ class FlatESLint {
             errorOnUnmatchedPattern
         } = eslintOptions;
         const startTime = Date.now();
-        const usedConfigs = [];
         const fixTypesSet = fixTypes ? new Set(fixTypes) : null;
 
         // Delete cache file; should this be done here?
@@ -847,15 +809,6 @@ class FlatESLint {
                     return void 0;
                 }
 
-                /*
-                 * Store used configs for:
-                 * - this method uses to collect used deprecated rules.
-                 * - `--fix-type` option uses to get the loaded rule's meta data.
-                 */
-                if (!usedConfigs.includes(config)) {
-                    usedConfigs.push(config);
-                }
-
                 // Skip if there is cached result.
                 if (lintResultCache) {
                     const cachedResult =
@@ -924,22 +877,10 @@ class FlatESLint {
             lintResultCache.reconcile();
         }
 
-        let usedDeprecatedRules;
         const finalResults = results.filter(result => !!result);
 
         return processLintReport(this, {
-            results: finalResults,
-            ...calculateStatsPerRun(finalResults),
-
-            // Initialize it lazily because CLI and `ESLint` API don't use it.
-            get usedDeprecatedRules() {
-                if (!usedDeprecatedRules) {
-                    usedDeprecatedRules = Array.from(
-                        iterateRuleDeprecationWarnings(usedConfigs)
-                    );
-                }
-                return usedDeprecatedRules;
-            }
+            results: finalResults
         });
     }
 
@@ -1001,7 +942,6 @@ class FlatESLint {
         const results = [];
         const startTime = Date.now();
         const resolvedFilename = path.resolve(cwd, filePath || "__placeholder__.js");
-        let config;
 
         // Clear the last used config arrays.
         if (resolvedFilename && await this.isPathIgnored(resolvedFilename)) {
@@ -1010,9 +950,6 @@ class FlatESLint {
             }
         } else {
 
-            // TODO: Needed?
-            config = configs.getConfig(resolvedFilename);
-
             // Do lint.
             results.push(verifyText({
                 text: code,
@@ -1027,21 +964,9 @@ class FlatESLint {
         }
 
         debug(`Linting complete in: ${Date.now() - startTime}ms`);
-        let usedDeprecatedRules;
 
         return processLintReport(this, {
-            results,
-            ...calculateStatsPerRun(results),
-
-            // Initialize it lazily because CLI and `ESLint` API don't use it.
-            get usedDeprecatedRules() {
-                if (!usedDeprecatedRules) {
-                    usedDeprecatedRules = Array.from(
-                        iterateRuleDeprecationWarnings(config)
-                    );
-                }
-                return usedDeprecatedRules;
-            }
+            results
         });
 
     }
@@ -1160,6 +1085,19 @@ class FlatESLint {
         return configs.getConfig(absolutePath);
     }
 
+    /**
+     * Finds the config file being used by this instance based on the options
+     * passed to the constructor.
+     * @returns {string|undefined} The path to the config file being used or
+     *      `undefined` if no config file is being used.
+     */
+    async findConfigFile() {
+        const options = privateMembers.get(this).options;
+        const { configFilePath } = await locateConfigFileToUse(options);
+
+        return configFilePath;
+    }
+
     /**
      * Checks if a given path is ignored by ESLint.
      * @param {string} filePath The path of the file to check.
@@ -1172,11 +1110,31 @@ class FlatESLint {
     }
 }
 
+/**
+ * Returns whether flat config should be used.
+ * @returns {Promise<boolean>} Whether flat config should be used.
+ */
+async function shouldUseFlatConfig() {
+    switch (process.env.ESLINT_USE_FLAT_CONFIG) {
+        case "true":
+            return true;
+        case "false":
+            return false;
+        default:
+
+            /*
+             * If neither explicitly enabled nor disabled, then use the presence
+             * of a flat config file to determine enablement.
+             */
+            return !!(await findFlatConfigFile(process.cwd()));
+    }
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
 
 module.exports = {
     FlatESLint,
-    findFlatConfigFile
+    shouldUseFlatConfig
 };

package/lib/linter/apply-disable-directives.js

@@ -5,6 +5,16 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @typedef {import("../shared/types").LintMessage} LintMessage */
+
+//------------------------------------------------------------------------------
+// Module Definition
+//------------------------------------------------------------------------------
+
 const escapeRegExp = require("escape-string-regexp");
 
 /**
@@ -196,7 +206,7 @@ function processUnusedDisableDirectives(allDirectives) {
  * @param {Object} options options for applying directives. This is the same as the options
  * for the exported function, except that `reportUnusedDisableDirectives` is not supported
  * (this function always reports unused disable directives).
- * @returns {{problems: Problem[], unusedDisableDirectives: Problem[]}} An object with a list
+ * @returns {{problems: LintMessage[], unusedDisableDirectives: LintMessage[]}} An object with a list
  * of problems (including suppressed ones) and unused eslint-disable directives
  */
 function applyDirectives(options) {

package/lib/linter/code-path-analysis/debug-helpers.js

@@ -109,7 +109,7 @@ module.exports = {
             text += "final[label=\"\",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];\n";
         }
         if (codePath.thrownSegments.length > 0) {
-            text += "thrown[label=\"✘\",shape=circle,width=0.3,height=0.3,fixedsize];\n";
+            text += "thrown[label=\"✘\",shape=circle,width=0.3,height=0.3,fixedsize=true];\n";
         }
 
         const traceMap = Object.create(null);

package/lib/linter/config-comment-parser.js

@@ -19,6 +19,12 @@ const levn = require("levn"),
 
 const debug = require("debug")("eslint:config-comment-parser");
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @typedef {import("../shared/types").LintMessage} LintMessage */
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -61,7 +67,7 @@ module.exports = class ConfigCommentParser {
      * Parses a JSON-like config.
      * @param {string} string The string to parse.
      * @param {Object} location Start line and column of comments for potential error message.
-     * @returns {({success: true, config: Object}|{success: false, error: Problem})} Result map object
+     * @returns {({success: true, config: Object}|{success: false, error: LintMessage})} Result map object
      */
     parseJsonConfig(string, location) {
         debug("Parsing JSON config");
@@ -109,7 +115,8 @@ module.exports = class ConfigCommentParser {
                     severity: 2,
                     message: `Failed to parse JSON from '${normalizedString}': ${ex.message}`,
                     line: location.start.line,
-                    column: location.start.column + 1
+                    column: location.start.column + 1,
+                    nodeType: null
                 }
             };
 

package/lib/linter/linter.js

@@ -364,7 +364,7 @@ function extractDirectiveComment(value) {
  * @param {ASTNode} ast The top node of the AST.
  * @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.
- * @returns {{configuredRules: Object, enabledGlobals: {value:string,comment:Token}[], exportedVariables: Object, problems: Problem[], disableDirectives: DisableDirective[]}}
+ * @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(ast, ruleMapper, warnInlineConfig) {
@@ -592,7 +592,7 @@ function findEslintEnv(text) {
  * Convert "/path/to/<text>" to "<text>".
  * `CLIEngine#executeOnText()` method gives "/path/to/<text>" if the filename
  * was omitted because `configArray.extractConfig()` requires an absolute path.
- * But the linter should pass `<text>` to `RuleContext#getFilename()` in that
+ * But the linter should pass `<text>` to `RuleContext#filename` in that
  * case.
  * Also, code blocks can have their virtual filename. If the parent filename was
  * `<text>`, the virtual filename is `<text>/0_foo.js` or something like (i.e.,
@@ -775,7 +775,7 @@ function analyzeScope(ast, languageOptions, visitorKeys) {
  * @param {string} text The text to parse.
  * @param {LanguageOptions} languageOptions Options to pass to the parser
  * @param {string} filePath The path to the file being parsed.
- * @returns {{success: false, error: Problem}|{success: true, sourceCode: SourceCode}}
+ * @returns {{success: false, error: LintMessage}|{success: true, sourceCode: SourceCode}}
  * An object containing the AST and parser services if parsing was successful, or the error if parsing failed
  * @private
  */
@@ -851,7 +851,8 @@ function parse(text, languageOptions, filePath) {
                 severity: 2,
                 message,
                 line: ex.lineNumber,
-                column: ex.column
+                column: ex.column,
+                nodeType: null
             }
         };
     }
@@ -902,7 +903,7 @@ const BASE_TRAVERSAL_CONTEXT = Object.freeze(
         (contextInfo, methodName) =>
             Object.assign(contextInfo, {
                 [methodName](...args) {
-                    return this.getSourceCode()[DEPRECATED_SOURCECODE_PASSTHROUGHS[methodName]](...args);
+                    return this.sourceCode[DEPRECATED_SOURCECODE_PASSTHROUGHS[methodName]](...args);
                 }
             }),
         {}
@@ -921,7 +922,7 @@ 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
- * @returns {Problem[]} An array of reported problems
+ * @returns {LintMessage[]} An array of reported problems
  */
 function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageOptions, settings, filename, disableFixes, cwd, physicalFilename) {
     const emitter = createEmitter();
@@ -951,10 +952,14 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
                 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
@@ -1249,7 +1254,8 @@ class Linter {
                     severity: 2,
                     message: `Configured parser '${config.parser}' was not found.`,
                     line: 0,
-                    column: 0
+                    column: 0,
+                    nodeType: null
                 }];
             }
             parserName = config.parser;
@@ -1460,7 +1466,8 @@ class Linter {
                     severity: 2,
                     message,
                     line: ex.lineNumber,
-                    column: ex.column
+                    column: ex.column,
+                    nodeType: null
                 }
             ];
         }
@@ -1725,7 +1732,8 @@ class Linter {
                     severity: 1,
                     message: `No matching configuration found for ${filename}.`,
                     line: 0,
-                    column: 0
+                    column: 0,
+                    nodeType: null
                 }
             ];
         }
@@ -1790,7 +1798,8 @@ class Linter {
                     severity: 2,
                     message,
                     line: ex.lineNumber,
-                    column: ex.column
+                    column: ex.column,
+                    nodeType: null
                 }
             ];
         }
@@ -1836,7 +1845,7 @@ class Linter {
     /**
      * Given a list of reported problems, distinguish problems between normal messages and suppressed messages.
      * The normal messages will be returned and the suppressed messages will be stored as lastSuppressedMessages.
-     * @param {Problem[]} problems A list of reported problems.
+     * @param {Array<LintMessage|SuppressedLintMessage>} problems A list of reported problems.
      * @returns {LintMessage[]} A list of LintMessage.
      */
     _distinguishSuppressedMessages(problems) {