eslint 8.47.0 → 8.57.0

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

@@ -15,7 +15,10 @@ const levn = require("levn"),
         Legacy: {
             ConfigOps
         }
-    } = require("@eslint/eslintrc/universal");
+    } = require("@eslint/eslintrc/universal"),
+    {
+        directivesPattern
+    } = require("../shared/directives");
 
 const debug = require("debug")("eslint:config-comment-parser");
 
@@ -139,7 +142,7 @@ module.exports = class ConfigCommentParser {
         const items = {};
 
         string.split(",").forEach(name => {
-            const trimmedName = name.trim();
+            const trimmedName = name.trim().replace(/^(?<quote>['"]?)(?<ruleId>.*)\k<quote>$/us, "$<ruleId>");
 
             if (trimmedName) {
                 items[trimmedName] = true;
@@ -148,4 +151,35 @@ module.exports = class ConfigCommentParser {
         return items;
     }
 
+    /**
+     * Extract the directive and the justification from a given directive comment and trim them.
+     * @param {string} value The comment text to extract.
+     * @returns {{directivePart: string, justificationPart: string}} The extracted directive and justification.
+     */
+    extractDirectiveComment(value) {
+        const match = /\s-{2,}\s/u.exec(value);
+
+        if (!match) {
+            return { directivePart: value.trim(), justificationPart: "" };
+        }
+
+        const directive = value.slice(0, match.index).trim();
+        const justification = value.slice(match.index + match[0].length).trim();
+
+        return { directivePart: directive, justificationPart: justification };
+    }
+
+    /**
+     * Parses a directive comment into directive text and value.
+     * @param {Comment} comment The comment node with the directive to be parsed.
+     * @returns {{directiveText: string, directiveValue: string}} The directive text and value.
+     */
+    parseDirective(comment) {
+        const { directivePart } = this.extractDirectiveComment(comment.value);
+        const match = directivesPattern.exec(directivePart);
+        const directiveText = match[1];
+        const directiveValue = directivePart.slice(match.index + directiveText.length);
+
+        return { directiveText, directiveValue };
+    }
 };

package/lib/linter/linter.js

@@ -42,7 +42,9 @@ const
     ruleReplacements = require("../../conf/replacements.json");
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
 const { FlatConfigArray } = require("../config/flat-config-array");
-
+const { RuleValidator } = require("../config/rule-validator");
+const { assertIsRuleOptions, assertIsRuleSeverity } = require("../config/flat-config-schema");
+const { normalizeSeverityToString } = require("../shared/severity");
 const debug = require("debug")("eslint:linter");
 const MAX_AUTOFIX_PASSES = 10;
 const DEFAULT_PARSER_NAME = "espree";
@@ -50,7 +52,6 @@ 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 globals = require("../../conf/globals");
 
 //------------------------------------------------------------------------------
 // Typedefs
@@ -145,29 +146,6 @@ function isEspree(parser) {
     return !!(parser === espree || parser[parserSymbol] === espree);
 }
 
-/**
- * Retrieves globals for the given ecmaVersion.
- * @param {number} ecmaVersion The version to retrieve globals for.
- * @returns {Object} The globals for the given ecmaVersion.
- */
-function getGlobalsForEcmaVersion(ecmaVersion) {
-
-    switch (ecmaVersion) {
-        case 3:
-            return globals.es3;
-
-        case 5:
-            return globals.es5;
-
-        default:
-            if (ecmaVersion < 2015) {
-                return globals[`es${ecmaVersion + 2009}`];
-            }
-
-            return globals[`es${ecmaVersion}`];
-    }
-}
-
 /**
  * Ensures that variables representing built-in properties of the Global Object,
  * and any globals declared by special block comments, are present in the global
@@ -339,35 +317,17 @@ function createDisableDirectives(options) {
     return result;
 }
 
-/**
- * Extract the directive and the justification from a given directive comment and trim them.
- * @param {string} value The comment text to extract.
- * @returns {{directivePart: string, justificationPart: string}} The extracted directive and justification.
- */
-function extractDirectiveComment(value) {
-    const match = /\s-{2,}\s/u.exec(value);
-
-    if (!match) {
-        return { directivePart: value.trim(), justificationPart: "" };
-    }
-
-    const directive = value.slice(0, match.index).trim();
-    const justification = value.slice(match.index + match[0].length).trim();
-
-    return { directivePart: directive, justificationPart: justification };
-}
-
 /**
  * Parses comments in file to extract file-specific config of rules, globals
  * and environments and merges them with global config; also code blocks
  * where reporting is disabled or enabled and merges them with reporting config.
- * @param {ASTNode} ast The top node of the AST.
+ * @param {SourceCode} sourceCode The SourceCode object to get comments from.
  * @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: 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) {
+function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
     const configuredRules = {};
     const enabledGlobals = Object.create(null);
     const exportedVariables = {};
@@ -377,8 +337,8 @@ function getDirectiveComments(ast, ruleMapper, warnInlineConfig) {
         builtInRules: Rules
     });
 
-    ast.comments.filter(token => token.type !== "Shebang").forEach(comment => {
-        const { directivePart, justificationPart } = extractDirectiveComment(comment.value);
+    sourceCode.getInlineConfigNodes().filter(token => token.type !== "Shebang").forEach(comment => {
+        const { directivePart, justificationPart } = commentParser.extractDirectiveComment(comment.value);
 
         const match = directivesPattern.exec(directivePart);
 
@@ -511,6 +471,69 @@ function getDirectiveComments(ast, ruleMapper, warnInlineConfig) {
     };
 }
 
+/**
+ * Parses comments in file to extract disable directives.
+ * @param {SourceCode} sourceCode The SourceCode object to get comments from.
+ * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules
+ * @returns {{problems: LintMessage[], disableDirectives: DisableDirective[]}}
+ * A collection of the directive comments that were found, along with any problems that occurred when parsing
+ */
+function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper) {
+    const problems = [];
+    const disableDirectives = [];
+
+    sourceCode.getInlineConfigNodes().filter(token => token.type !== "Shebang").forEach(comment => {
+        const { directivePart, justificationPart } = commentParser.extractDirectiveComment(comment.value);
+
+        const match = directivesPattern.exec(directivePart);
+
+        if (!match) {
+            return;
+        }
+        const directiveText = match[1];
+        const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);
+
+        if (comment.type === "Line" && !lineCommentSupported) {
+            return;
+        }
+
+        if (directiveText === "eslint-disable-line" && comment.loc.start.line !== comment.loc.end.line) {
+            const message = `${directiveText} comment should not span multiple lines.`;
+
+            problems.push(createLintingProblem({
+                ruleId: null,
+                message,
+                loc: comment.loc
+            }));
+            return;
+        }
+
+        const directiveValue = directivePart.slice(match.index + directiveText.length);
+
+        switch (directiveText) {
+            case "eslint-disable":
+            case "eslint-enable":
+            case "eslint-disable-next-line":
+            case "eslint-disable-line": {
+                const directiveType = directiveText.slice("eslint-".length);
+                const options = { commentToken: comment, type: directiveType, value: directiveValue, justification: justificationPart, ruleMapper };
+                const { directives, directiveProblems } = createDisableDirectives(options);
+
+                disableDirectives.push(...directives);
+                problems.push(...directiveProblems);
+                break;
+            }
+
+            // no default
+        }
+    });
+
+    return {
+        problems,
+        disableDirectives
+    };
+}
+
 /**
  * Normalize ECMAScript version from the initial config
  * @param {Parser} parser The parser which uses this options.
@@ -580,7 +603,7 @@ function findEslintEnv(text) {
         if (match[0].endsWith("*/")) {
             retv = Object.assign(
                 retv || {},
-                commentParser.parseListConfig(extractDirectiveComment(match[1]).directivePart)
+                commentParser.parseListConfig(commentParser.extractDirectiveComment(match[1]).directivePart)
             );
         }
     }
@@ -631,9 +654,11 @@ function normalizeVerifyOptions(providedOptions, config) {
         reportUnusedDisableDirectives = reportUnusedDisableDirectives ? "error" : "off";
     }
     if (typeof reportUnusedDisableDirectives !== "string") {
-        reportUnusedDisableDirectives =
-            linterOptions.reportUnusedDisableDirectives
-                ? "warn" : "off";
+        if (typeof linterOptions.reportUnusedDisableDirectives === "boolean") {
+            reportUnusedDisableDirectives = linterOptions.reportUnusedDisableDirectives ? "warn" : "off";
+        } else {
+            reportUnusedDisableDirectives = linterOptions.reportUnusedDisableDirectives === void 0 ? "off" : normalizeSeverityToString(linterOptions.reportUnusedDisableDirectives);
+        }
     }
 
     return {
@@ -898,6 +923,7 @@ const DEPRECATED_SOURCECODE_PASSTHROUGHS = {
     getTokensBetween: "getTokensBetween"
 };
 
+
 const BASE_TRAVERSAL_CONTEXT = Object.freeze(
     Object.keys(DEPRECATED_SOURCECODE_PASSTHROUGHS).reduce(
         (contextInfo, methodName) =>
@@ -1312,7 +1338,7 @@ class Linter {
 
         const sourceCode = slots.lastSourceCode;
         const commentDirectives = options.allowInlineConfig
-            ? getDirectiveComments(sourceCode.ast, ruleId => getRule(slots, ruleId), options.warnInlineConfig)
+            ? getDirectiveComments(sourceCode, ruleId => getRule(slots, ruleId), options.warnInlineConfig)
             : { configuredRules: {}, enabledGlobals: {}, exportedVariables: {}, problems: [], disableDirectives: [] };
 
         // augment global scope with declared global variables
@@ -1323,7 +1349,6 @@ class Linter {
         );
 
         const configuredRules = Object.assign({}, config.rules, commentDirectives.configuredRules);
-
         let lintingProblems;
 
         try {
@@ -1382,7 +1407,7 @@ class Linter {
     verify(textOrSourceCode, config, filenameOrOptions) {
         debug("Verify");
 
-        const { configType } = internalSlotsMap.get(this);
+        const { configType, cwd } = internalSlotsMap.get(this);
 
         const options = typeof filenameOrOptions === "string"
             ? { filename: filenameOrOptions }
@@ -1401,7 +1426,7 @@ class Linter {
                 let configArray = config;
 
                 if (!Array.isArray(config) || typeof config.getConfig !== "function") {
-                    configArray = new FlatConfigArray(config);
+                    configArray = new FlatConfigArray(config, { basePath: cwd });
                     configArray.normalizeSync();
                 }
 
@@ -1539,19 +1564,6 @@ class Linter {
             languageOptions.ecmaVersion
         );
 
-        /*
-         * add configured globals and language globals
-         *
-         * using Object.assign instead of object spread for performance reasons
-         * https://github.com/eslint/eslint/issues/16302
-         */
-        const configuredGlobals = Object.assign(
-            {},
-            getGlobalsForEcmaVersion(languageOptions.ecmaVersion),
-            languageOptions.sourceType === "commonjs" ? globals.commonjs : void 0,
-            languageOptions.globals
-        );
-
         // double check that there is a parser to avoid mysterious error messages
         if (!languageOptions.parser) {
             throw new TypeError(`No parser specified for ${options.filename}`);
@@ -1607,25 +1619,113 @@ class Linter {
         }
 
         const sourceCode = slots.lastSourceCode;
-        const commentDirectives = options.allowInlineConfig
-            ? getDirectiveComments(
-                sourceCode.ast,
-                ruleId => getRuleFromConfig(ruleId, config),
-                options.warnInlineConfig
-            )
-            : { configuredRules: {}, enabledGlobals: {}, exportedVariables: {}, problems: [], disableDirectives: [] };
 
-        // augment global scope with declared global variables
-        addDeclaredGlobals(
-            sourceCode.scopeManager.scopes[0],
-            configuredGlobals,
-            { exportedVariables: commentDirectives.exportedVariables, enabledGlobals: commentDirectives.enabledGlobals }
-        );
+        /*
+         * Make adjustments based on the language options. For JavaScript,
+         * this is primarily about adding variables into the global scope
+         * to account for ecmaVersion and configured globals.
+         */
+        sourceCode.applyLanguageOptions(languageOptions);
 
-        const configuredRules = Object.assign({}, config.rules, commentDirectives.configuredRules);
+        const mergedInlineConfig = {
+            rules: {}
+        };
+        const inlineConfigProblems = [];
 
+        /*
+         * Inline config can be either enabled or disabled. If disabled, it's possible
+         * to detect the inline config and emit a warning (though this is not required).
+         * So we first check to see if inline config is allowed at all, and if so, we
+         * need to check if it's a warning or not.
+         */
+        if (options.allowInlineConfig) {
+
+            // if inline config should warn then add the warnings
+            if (options.warnInlineConfig) {
+                sourceCode.getInlineConfigNodes().forEach(node => {
+                    inlineConfigProblems.push(createLintingProblem({
+                        ruleId: null,
+                        message: `'${sourceCode.text.slice(node.range[0], node.range[1])}' has no effect because you have 'noInlineConfig' setting in ${options.warnInlineConfig}.`,
+                        loc: node.loc,
+                        severity: 1
+                    }));
+
+                });
+            } else {
+                const inlineConfigResult = sourceCode.applyInlineConfig();
+
+                inlineConfigProblems.push(
+                    ...inlineConfigResult.problems
+                        .map(createLintingProblem)
+                        .map(problem => {
+                            problem.fatal = true;
+                            return problem;
+                        })
+                );
+
+                // next we need to verify information about the specified rules
+                const ruleValidator = new RuleValidator();
+
+                for (const { config: inlineConfig, node } of inlineConfigResult.configs) {
+
+                    Object.keys(inlineConfig.rules).forEach(ruleId => {
+                        const rule = getRuleFromConfig(ruleId, config);
+                        const ruleValue = inlineConfig.rules[ruleId];
+
+                        if (!rule) {
+                            inlineConfigProblems.push(createLintingProblem({ ruleId, loc: node.loc }));
+                            return;
+                        }
+
+                        try {
+
+                            const ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+
+                            assertIsRuleOptions(ruleId, ruleValue);
+                            assertIsRuleSeverity(ruleId, ruleOptions[0]);
+
+                            ruleValidator.validate({
+                                plugins: config.plugins,
+                                rules: {
+                                    [ruleId]: ruleOptions
+                                }
+                            });
+                            mergedInlineConfig.rules[ruleId] = ruleValue;
+                        } catch (err) {
+
+                            let baseMessage = err.message.slice(
+                                err.message.startsWith("Key \"rules\":")
+                                    ? err.message.indexOf(":", 12) + 1
+                                    : err.message.indexOf(":") + 1
+                            ).trim();
+
+                            if (err.messageTemplate) {
+                                baseMessage += ` You passed "${ruleValue}".`;
+                            }
+
+                            inlineConfigProblems.push(createLintingProblem({
+                                ruleId,
+                                message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`,
+                                loc: node.loc
+                            }));
+                        }
+                    });
+                }
+            }
+        }
+
+        const commentDirectives = options.allowInlineConfig && !options.warnInlineConfig
+            ? getDirectiveCommentsForFlatConfig(
+                sourceCode,
+                ruleId => getRuleFromConfig(ruleId, config)
+            )
+            : { problems: [], disableDirectives: [] };
+
+        const configuredRules = Object.assign({}, config.rules, mergedInlineConfig.rules);
         let lintingProblems;
 
+        sourceCode.finalize();
+
         try {
             lintingProblems = runRules(
                 sourceCode,
@@ -1666,6 +1766,7 @@ class Linter {
             disableFixes: options.disableFixes,
             problems: lintingProblems
                 .concat(commentDirectives.problems)
+                .concat(inlineConfigProblems)
                 .sort((problemA, problemB) => problemA.line - problemB.line || problemA.column - problemB.column),
             reportUnusedDisableDirectives: options.reportUnusedDisableDirectives
         });

package/lib/options.js

@@ -47,7 +47,8 @@ const optionator = require("optionator");
  * @property {Object} [parserOptions] Specify parser options
  * @property {string[]} [plugin] Specify plugins
  * @property {string} [printConfig] Print the configuration for the given file
- * @property {boolean | undefined} reportUnusedDisableDirectives Adds reported errors for unused eslint-disable directives
+ * @property {boolean | undefined} reportUnusedDisableDirectives Adds reported errors for unused eslint-disable and eslint-enable directives
+ * @property {string | undefined} reportUnusedDisableDirectivesSeverity A severity string indicating if and how unused disable and enable directives should be tracked and reported.
  * @property {string} [resolvePluginsRelativeTo] A folder where plugins should be resolved from, CWD by default
  * @property {Object} [rule] Specify rules
  * @property {string[]} [rulesdir] Load additional rules from this directory. Deprecated: Use rules from plugins
@@ -55,6 +56,7 @@ const optionator = require("optionator");
  * @property {string} [stdinFilename] Specify filename to process STDIN as
  * @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 {string[]} _ Positional filenames or patterns
  */
 
@@ -139,6 +141,17 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let warnIgnoredFlag;
+
+    if (usingFlatConfig) {
+        warnIgnoredFlag = {
+            option: "warn-ignored",
+            type: "Boolean",
+            default: "true",
+            description: "Suppress warnings when the file list includes ignored files"
+        };
+    }
+
     return optionator({
         prepend: "eslint [options] file.js [file.js] [dir]",
         defaults: {
@@ -155,7 +168,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,
@@ -292,7 +305,14 @@ module.exports = function(usingFlatConfig) {
                 option: "report-unused-disable-directives",
                 type: "Boolean",
                 default: void 0,
-                description: "Adds reported errors for unused eslint-disable directives"
+                description: "Adds reported errors for unused eslint-disable and eslint-enable directives"
+            },
+            {
+                option: "report-unused-disable-directives-severity",
+                type: "String",
+                default: void 0,
+                description: "Chooses severity level for reporting unused eslint-disable and eslint-enable directives",
+                enum: ["off", "warn", "error", "0", "1", "2"]
             },
             {
                 heading: "Caching"
@@ -349,6 +369,7 @@ module.exports = function(usingFlatConfig) {
                 default: "false",
                 description: "Exit with exit code 2 in case of fatal error"
             },
+            warnIgnoredFlag,
             {
                 option: "debug",
                 type: "Boolean",