immosquare-cleaner 0.1.39 → 0.1.41

data/node_modules/eslint/lib/linter/linter.js

@@ -17,7 +17,6 @@ const
     espree = require("espree"),
     merge = require("lodash.merge"),
     pkg = require("../../package.json"),
-    astUtils = require("../shared/ast-utils"),
     {
         directivesPattern
     } = require("../shared/directives"),
@@ -29,7 +28,7 @@ const
         }
     } = require("@eslint/eslintrc/universal"),
     Traverser = require("../shared/traverser"),
-    { SourceCode } = require("../source-code"),
+    { SourceCode } = require("../languages/js/source-code"),
     applyDisableDirectives = require("./apply-disable-directives"),
     ConfigCommentParser = require("./config-comment-parser"),
     NodeEventGenerator = require("./node-event-generator"),
@@ -45,6 +44,8 @@ const { startTime, endTime } = require("../shared/stats");
 const { RuleValidator } = require("../config/rule-validator");
 const { assertIsRuleSeverity } = require("../config/flat-config-schema");
 const { normalizeSeverityToString } = require("../shared/severity");
+const jslang = require("../languages/js");
+const { activeFlags } = require("../shared/flags");
 const debug = require("debug")("eslint:linter");
 const MAX_AUTOFIX_PASSES = 10;
 const DEFAULT_PARSER_NAME = "espree";
@@ -53,6 +54,7 @@ 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 { LATEST_ECMA_VERSION } = require("../../conf/ecma-version");
+const { VFile } = require("./vfile");
 const STEP_KIND_VISIT = 1;
 const STEP_KIND_CALL = 2;
 
@@ -70,6 +72,10 @@ const STEP_KIND_CALL = 2;
 /** @typedef {import("../shared/types").Processor} Processor */
 /** @typedef {import("../shared/types").Rule} Rule */
 /** @typedef {import("../shared/types").Times} Times */
+/** @typedef {import("@eslint/core").Language} Language */
+/** @typedef {import("@eslint/core").RuleSeverity} RuleSeverity */
+/** @typedef {import("@eslint/core").RuleConfig} RuleConfig */
+
 
 /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */
 /**
@@ -239,13 +245,43 @@ function createMissingRuleMessage(ruleId) {
         : `Definition for rule '${ruleId}' was not found.`;
 }
 
+/**
+ * Updates a given location based on the language offsets. This allows us to
+ * change 0-based locations to 1-based locations. We always want ESLint
+ * reporting lines and columns starting from 1.
+ * @param {Object} location The location to update.
+ * @param {number} location.line The starting line number.
+ * @param {number} location.column The starting column number.
+ * @param {number} [location.endLine] The ending line number.
+ * @param {number} [location.endColumn] The ending column number.
+ * @param {Language} language The language to use to adjust the location information.
+ * @returns {Object} The updated location.
+ */
+function updateLocationInformation({ line, column, endLine, endColumn }, language) {
+
+    const columnOffset = language.columnStart === 1 ? 0 : 1;
+    const lineOffset = language.lineStart === 1 ? 0 : 1;
+
+    // calculate separately to account for undefined
+    const finalEndLine = endLine === void 0 ? endLine : endLine + lineOffset;
+    const finalEndColumn = endColumn === void 0 ? endColumn : endColumn + columnOffset;
+
+    return {
+        line: line + lineOffset,
+        column: column + columnOffset,
+        endLine: finalEndLine,
+        endColumn: finalEndColumn
+    };
+}
+
 /**
  * creates a linting problem
  * @param {Object} options to create linting error
  * @param {string} [options.ruleId] the ruleId to report
  * @param {Object} [options.loc] the loc to report
  * @param {string} [options.message] the error message to report
- * @param {string} [options.severity] the error message to report
+ * @param {RuleSeverity} [options.severity] the error message to report
+ * @param {Language} [options.language] the language to use to adjust the location information
  * @returns {LintMessage} created problem, returns a missing-rule problem if only provided ruleId.
  * @private
  */
@@ -254,16 +290,24 @@ function createLintingProblem(options) {
         ruleId = null,
         loc = DEFAULT_ERROR_LOC,
         message = createMissingRuleMessage(options.ruleId),
-        severity = 2
+        severity = 2,
+
+        // fallback for eslintrc mode
+        language = {
+            columnStart: 0,
+            lineStart: 1
+        }
     } = options;
 
     return {
         ruleId,
         message,
-        line: loc.start.line,
-        column: loc.start.column + 1,
-        endLine: loc.end.line,
-        endColumn: loc.end.column + 1,
+        ...updateLocationInformation({
+            line: loc.start.line,
+            column: loc.start.column,
+            endLine: loc.end.line,
+            endColumn: loc.end.column
+        }, language),
         severity,
         nodeType: null
     };
@@ -278,9 +322,10 @@ function createLintingProblem(options) {
  * @param {string} options.justification The justification of the directive
  * @param {ASTNode|token} options.node The Comment node/token.
  * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules
+ * @param {Language} language The language to use to adjust the location information.
  * @returns {Object} Directives and problems from the comment
  */
-function createDisableDirectives({ type, value, justification, node }, ruleMapper) {
+function createDisableDirectives({ type, value, justification, node }, ruleMapper, language) {
     const ruleIds = Object.keys(commentParser.parseListConfig(value));
     const directiveRules = ruleIds.length ? ruleIds : [null];
     const result = {
@@ -294,26 +339,36 @@ function createDisableDirectives({ type, value, justification, node }, ruleMappe
         // push to directives, if the rule is defined(including null, e.g. /*eslint enable*/)
         if (ruleId === null || !!ruleMapper(ruleId)) {
             if (type === "disable-next-line") {
+                const { line, column } = updateLocationInformation(
+                    node.loc.end,
+                    language
+                );
+
                 result.directives.push({
                     parentDirective,
                     type,
-                    line: node.loc.end.line,
-                    column: node.loc.end.column + 1,
+                    line,
+                    column,
                     ruleId,
                     justification
                 });
             } else {
+                const { line, column } = updateLocationInformation(
+                    node.loc.start,
+                    language
+                );
+
                 result.directives.push({
                     parentDirective,
                     type,
-                    line: node.loc.start.line,
-                    column: node.loc.start.column + 1,
+                    line,
+                    column,
                     ruleId,
                     justification
                 });
             }
         } else {
-            result.directiveProblems.push(createLintingProblem({ ruleId, loc: node.loc }));
+            result.directiveProblems.push(createLintingProblem({ ruleId, loc: node.loc, language }));
         }
     }
     return result;
@@ -391,7 +446,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                     value: directiveValue,
                     justification: justificationPart,
                     node: comment
-                }, ruleMapper);
+                }, ruleMapper, jslang);
 
                 disableDirectives.push(...directives);
                 problems.push(...directiveProblems);
@@ -431,7 +486,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                 break;
 
             case "eslint": {
-                const parseResult = commentParser.parseJsonConfig(directiveValue, comment.loc);
+                const parseResult = commentParser.parseJsonConfig(directiveValue);
 
                 if (parseResult.success) {
                     Object.keys(parseResult.config).forEach(name => {
@@ -518,7 +573,14 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                         configuredRules[name] = ruleOptions;
                     });
                 } else {
-                    problems.push(parseResult.error);
+                    const problem = createLintingProblem({
+                        ruleId: null,
+                        loc: comment.loc,
+                        message: parseResult.error.message
+                    });
+
+                    problem.fatal = true;
+                    problems.push(problem);
                 }
 
                 break;
@@ -541,26 +603,32 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
  * 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
+ * @param {Language} language The language to use to adjust the location information
  * @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) {
+function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper, language) {
     const disableDirectives = [];
     const problems = [];
 
-    const {
-        directives: directivesSources,
-        problems: directivesProblems
-    } = sourceCode.getDisableDirectives();
+    if (sourceCode.getDisableDirectives) {
+        const {
+            directives: directivesSources,
+            problems: directivesProblems
+        } = sourceCode.getDisableDirectives();
 
-    problems.push(...directivesProblems.map(createLintingProblem));
+        problems.push(...directivesProblems.map(directiveProblem => createLintingProblem({
+            ...directiveProblem,
+            language
+        })));
 
-    directivesSources.forEach(directive => {
-        const { directives, directiveProblems } = createDisableDirectives(directive, ruleMapper);
+        directivesSources.forEach(directive => {
+            const { directives, directiveProblems } = createDisableDirectives(directive, ruleMapper, language);
 
-        disableDirectives.push(...directives);
-        problems.push(...directiveProblems);
-    });
+            disableDirectives.push(...directives);
+            problems.push(...directiveProblems);
+        });
+    }
 
     return {
         problems,
@@ -781,24 +849,6 @@ function resolveGlobals(providedGlobals, enabledEnvironments) {
     );
 }
 
-/**
- * Strips Unicode BOM from a given text.
- * @param {string} text A text to strip.
- * @returns {string} The stripped text.
- */
-function stripUnicodeBOM(text) {
-
-    /*
-     * Check Unicode BOM.
-     * In JavaScript, string data is stored as UTF-16, so BOM is 0xFEFF.
-     * http://www.ecma-international.org/ecma-262/6.0/#sec-unicode-format-control-characters
-     */
-    if (text.charCodeAt(0) === 0xFEFF) {
-        return text.slice(1);
-    }
-    return text;
-}
-
 /**
  * Store time measurements in map
  * @param {number} time Time measurement
@@ -831,7 +881,7 @@ function storeTime(time, timeOpts, slots) {
 
 /**
  * Get the options for a rule (not including severity), if any
- * @param {Array|number} ruleConfig rule configuration
+ * @param {RuleConfig} ruleConfig rule configuration
  * @returns {Array} of rule options, empty Array if none
  */
 function getRuleOptions(ruleConfig) {
@@ -866,93 +916,40 @@ function analyzeScope(ast, languageOptions, visitorKeys) {
 }
 
 /**
- * Parses text into an AST. Moved out here because the try-catch prevents
+ * Parses file into an AST. Moved out here because the try-catch prevents
  * optimization of functions, so it's best to keep the try-catch as isolated
  * as possible
- * @param {string} text The text to parse.
+ * @param {VFile} file The file to parse.
+ * @param {Language} language The language to use.
  * @param {LanguageOptions} languageOptions Options to pass to the parser
- * @param {string} filePath The path to the file being parsed.
  * @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
  */
-function parse(text, languageOptions, filePath) {
-    const textToParse = stripUnicodeBOM(text).replace(astUtils.shebangPattern, (match, captured) => `//${captured}`);
-    const { ecmaVersion, sourceType, parser } = languageOptions;
-    const parserOptions = Object.assign(
-        { ecmaVersion, sourceType },
-        languageOptions.parserOptions,
-        {
-            loc: true,
-            range: true,
-            raw: true,
-            tokens: true,
-            comment: true,
-            eslintVisitorKeys: true,
-            eslintScopeManager: true,
-            filePath
-        }
-    );
-
-    /*
-     * Check for parsing errors first. If there's a parsing error, nothing
-     * else can happen. However, a parsing error does not throw an error
-     * from this method - it's just considered a fatal error message, a
-     * problem that ESLint identified just like any other.
-     */
-    try {
-        debug("Parsing:", filePath);
-        const parseResult = (typeof parser.parseForESLint === "function")
-            ? parser.parseForESLint(textToParse, parserOptions)
-            : { ast: parser.parse(textToParse, parserOptions) };
-
-        debug("Parsing successful:", filePath);
-        const ast = parseResult.ast;
-        const parserServices = parseResult.services || {};
-        const visitorKeys = parseResult.visitorKeys || evk.KEYS;
-
-        debug("Scope analysis:", filePath);
-        const scopeManager = parseResult.scopeManager || analyzeScope(ast, languageOptions, visitorKeys);
+function parse(file, language, languageOptions) {
 
-        debug("Scope analysis successful:", filePath);
+    const result = language.parse(file, { languageOptions });
 
+    if (result.ok) {
         return {
             success: true,
-
-            /*
-             * Save all values that `parseForESLint()` returned.
-             * If a `SourceCode` object is given as the first parameter instead of source code text,
-             * linter skips the parsing process and reuses the source code object.
-             * In that case, linter needs all the values that `parseForESLint()` returned.
-             */
-            sourceCode: new SourceCode({
-                text,
-                ast,
-                parserServices,
-                scopeManager,
-                visitorKeys
-            })
-        };
-    } catch (ex) {
-
-        // If the message includes a leading line number, strip it:
-        const message = `Parsing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
-
-        debug("%s\n%s", message, ex.stack);
-
-        return {
-            success: false,
-            error: {
-                ruleId: null,
-                fatal: true,
-                severity: 2,
-                message,
-                line: ex.lineNumber,
-                column: ex.column,
-                nodeType: null
-            }
+            sourceCode: language.createSourceCode(file, result, { languageOptions })
         };
     }
+
+    // if we made it to here there was an error
+    return {
+        success: false,
+        errors: result.errors.map(error => ({
+            ruleId: null,
+            nodeType: null,
+            fatal: true,
+            severity: 2,
+            message: `Parsing error: ${error.message}`,
+            line: error.line,
+            column: error.column
+        }))
+    };
 }
 
 /**
@@ -983,6 +980,7 @@ function createRuleListeners(rule, ruleContext) {
  * @param {Object} configuredRules The rules configuration
  * @param {function(string): Rule} ruleMapper A mapper function from rule names to rules
  * @param {string | undefined} parserName The name of the parser in the config
+ * @param {Language} language The language object used for parsing.
  * @param {LanguageOptions} languageOptions The options for parsing the code.
  * @param {Object} settings The settings that were enabled in the config
  * @param {string} filename The reported filename of the code
@@ -995,8 +993,11 @@ function createRuleListeners(rule, ruleContext) {
  * @returns {LintMessage[]} An array of reported problems
  * @throws {Error} If traversal into a node fails.
  */
-function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageOptions, settings, filename, disableFixes, cwd, physicalFilename, ruleFilter,
-    stats, slots) {
+function runRules(
+    sourceCode, configuredRules, ruleMapper, parserName, language, languageOptions,
+    settings, filename, disableFixes, cwd, physicalFilename, ruleFilter,
+    stats, slots
+) {
     const emitter = createEmitter();
 
     // must happen first to assign all node.parent properties
@@ -1043,7 +1044,7 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
         const rule = ruleMapper(ruleId);
 
         if (!rule) {
-            lintingProblems.push(createLintingProblem({ ruleId }));
+            lintingProblems.push(createLintingProblem({ ruleId, language }));
             return;
         }
 
@@ -1073,7 +1074,8 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
                                 severity,
                                 sourceCode,
                                 messageIds,
-                                disableFixes
+                                disableFixes,
+                                language
                             });
                         }
                         const problem = reportTranslator(...args);
@@ -1144,7 +1146,12 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
         });
     });
 
-    const eventGenerator = new NodeEventGenerator(emitter, { visitorKeys: sourceCode.visitorKeys, fallback: Traverser.getKeys });
+    const eventGenerator = new NodeEventGenerator(emitter, {
+        visitorKeys: sourceCode.visitorKeys ?? language.visitorKeys,
+        fallback: Traverser.getKeys,
+        matchClass: language.matchesSelectorClass ?? (() => false),
+        nodeTypeKey: language.nodeTypeKey
+    });
 
     for (const step of eventQueue) {
         switch (step.kind) {
@@ -1271,11 +1278,13 @@ class Linter {
      * Initialize the Linter.
      * @param {Object} [config] the config object
      * @param {string} [config.cwd] path to a directory that should be considered as the current working directory, can be undefined.
+     * @param {Array<string>} [config.flags] the feature flags to enable.
      * @param {"flat"|"eslintrc"} [config.configType="flat"] the type of config used.
      */
-    constructor({ cwd, configType = "flat" } = {}) {
+    constructor({ cwd, configType = "flat", flags = [] } = {}) {
         internalSlotsMap.set(this, {
             cwd: normalizeCwd(cwd),
+            flags: flags.filter(flag => activeFlags.has(flag)),
             lastConfigArray: null,
             lastSourceCode: null,
             lastSuppressedMessages: [],
@@ -1296,6 +1305,15 @@ class Linter {
         return pkg.version;
     }
 
+    /**
+     * Indicates if the given feature flag is enabled for this instance.
+     * @param {string} flag The feature flag to check.
+     * @returns {boolean} `true` if the feature flag is enabled, `false` if not.
+     */
+    hasFlag(flag) {
+        return internalSlotsMap.get(this).flags.includes(flag);
+    }
+
     /**
      * Same as linter.verify, except without support for processors.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
@@ -1360,6 +1378,9 @@ class Linter {
             parser,
             parserOptions
         });
+        const file = new VFile(options.filename, text, {
+            physicalPath: providedOptions.physicalFilename
+        });
 
         if (!slots.lastSourceCode) {
             let t;
@@ -1369,9 +1390,9 @@ class Linter {
             }
 
             const parseResult = parse(
-                text,
-                languageOptions,
-                options.filename
+                file,
+                jslang,
+                languageOptions
             );
 
             if (options.stats) {
@@ -1382,7 +1403,7 @@ class Linter {
             }
 
             if (!parseResult.success) {
-                return [parseResult.error];
+                return parseResult.errors;
             }
 
             slots.lastSourceCode = parseResult.sourceCode;
@@ -1396,6 +1417,7 @@ class Linter {
                 slots.lastSourceCode = new SourceCode({
                     text: slots.lastSourceCode.text,
                     ast: slots.lastSourceCode.ast,
+                    hasBOM: slots.lastSourceCode.hasBOM,
                     parserServices: slots.lastSourceCode.parserServices,
                     visitorKeys: slots.lastSourceCode.visitorKeys,
                     scopeManager: analyzeScope(slots.lastSourceCode.ast, languageOptions)
@@ -1408,7 +1430,6 @@ class Linter {
             ? getDirectiveComments(sourceCode, ruleId => getRule(slots, ruleId), options.warnInlineConfig, config)
             : { configuredRules: {}, enabledGlobals: {}, exportedVariables: {}, problems: [], disableDirectives: [] };
 
-        // augment global scope with declared global variables
         addDeclaredGlobals(
             sourceCode.scopeManager.scopes[0],
             configuredGlobals,
@@ -1425,6 +1446,7 @@ class Linter {
                 configuredRules,
                 ruleId => getRule(slots, ruleId),
                 parserName,
+                jslang,
                 languageOptions,
                 settings,
                 options.filename,
@@ -1457,6 +1479,7 @@ class Linter {
         }
 
         return applyDisableDirectives({
+            language: jslang,
             directives: commentDirectives.disableDirectives,
             disableFixes: options.disableFixes,
             problems: lintingProblems
@@ -1659,6 +1682,9 @@ class Linter {
         }
 
         const settings = config.settings || {};
+        const file = new VFile(options.filename, text, {
+            physicalPath: providedOptions.physicalFilename
+        });
 
         if (!slots.lastSourceCode) {
             let t;
@@ -1668,9 +1694,9 @@ class Linter {
             }
 
             const parseResult = parse(
-                text,
-                languageOptions,
-                options.filename
+                file,
+                config.language,
+                languageOptions
             );
 
             if (options.stats) {
@@ -1680,7 +1706,7 @@ class Linter {
             }
 
             if (!parseResult.success) {
-                return [parseResult.error];
+                return parseResult.errors;
             }
 
             slots.lastSourceCode = parseResult.sourceCode;
@@ -1689,11 +1715,17 @@ class Linter {
             /*
              * If the given source code object as the first argument does not have scopeManager, analyze the scope.
              * This is for backward compatibility (SourceCode is frozen so it cannot rebind).
+             *
+             * We check explicitly for `null` to ensure that this is a JS-flavored language.
+             * For non-JS languages we don't want to do this.
+             *
+             * TODO: Remove this check when we stop exporting the `SourceCode` object.
              */
-            if (!slots.lastSourceCode.scopeManager) {
+            if (slots.lastSourceCode.scopeManager === null) {
                 slots.lastSourceCode = new SourceCode({
                     text: slots.lastSourceCode.text,
                     ast: slots.lastSourceCode.ast,
+                    hasBOM: slots.lastSourceCode.hasBOM,
                     parserServices: slots.lastSourceCode.parserServices,
                     visitorKeys: slots.lastSourceCode.visitorKeys,
                     scopeManager: analyzeScope(slots.lastSourceCode.ast, languageOptions)
@@ -1708,7 +1740,7 @@ class Linter {
          * this is primarily about adding variables into the global scope
          * to account for ecmaVersion and configured globals.
          */
-        sourceCode.applyLanguageOptions(languageOptions);
+        sourceCode.applyLanguageOptions?.(languageOptions);
 
         const mergedInlineConfig = {
             rules: {}
@@ -1725,140 +1757,151 @@ class Linter {
 
             // 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
-                    }));
+                if (sourceCode.getInlineConfigNodes) {
+                    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,
+                            language: config.language
+                        }));
 
-                });
+                    });
+                }
             } else {
-                const inlineConfigResult = sourceCode.applyInlineConfig();
-
-                inlineConfigProblems.push(
-                    ...inlineConfigResult.problems
-                        .map(createLintingProblem)
-                        .map(problem => {
-                            problem.fatal = true;
-                            return problem;
-                        })
-                );
+                const inlineConfigResult = sourceCode.applyInlineConfig?.();
+
+                if (inlineConfigResult) {
+                    inlineConfigProblems.push(
+                        ...inlineConfigResult.problems
+                            .map(problem => createLintingProblem({ ...problem, language: config.language }))
+                            .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, loc } 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,
+                                    language: config.language
+                                }));
+                                return;
+                            }
 
-                // next we need to verify information about the specified rules
-                const ruleValidator = new RuleValidator();
+                            if (Object.hasOwn(mergedInlineConfig.rules, ruleId)) {
+                                inlineConfigProblems.push(createLintingProblem({
+                                    message: `Rule "${ruleId}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
+                                    loc,
+                                    language: config.language
+                                }));
+                                return;
+                            }
 
-                for (const { config: inlineConfig, node } of inlineConfigResult.configs) {
+                            try {
 
-                    Object.keys(inlineConfig.rules).forEach(ruleId => {
-                        const rule = getRuleFromConfig(ruleId, config);
-                        const ruleValue = inlineConfig.rules[ruleId];
+                                let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
 
-                        if (!rule) {
-                            inlineConfigProblems.push(createLintingProblem({ ruleId, loc: node.loc }));
-                            return;
-                        }
+                                assertIsRuleSeverity(ruleId, ruleOptions[0]);
 
-                        if (Object.hasOwn(mergedInlineConfig.rules, ruleId)) {
-                            inlineConfigProblems.push(createLintingProblem({
-                                message: `Rule "${ruleId}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
-                                loc: node.loc
-                            }));
-                            return;
-                        }
+                                /*
+                                 * If the rule was already configured, inline rule configuration that
+                                 * only has severity should retain options from the config and just override the severity.
+                                 *
+                                 * Example:
+                                 *
+                                 *   {
+                                 *       rules: {
+                                 *           curly: ["error", "multi"]
+                                 *       }
+                                 *   }
+                                 *
+                                 *   /* eslint curly: ["warn"] * /
+                                 *
+                                 *   Results in:
+                                 *
+                                 *   curly: ["warn", "multi"]
+                                 */
 
-                        try {
+                                let shouldValidateOptions = true;
 
-                            let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+                                if (
 
-                            assertIsRuleSeverity(ruleId, ruleOptions[0]);
+                                    /*
+                                     * If inline config for the rule has only severity
+                                     */
+                                    ruleOptions.length === 1 &&
 
-                            /*
-                             * If the rule was already configured, inline rule configuration that
-                             * only has severity should retain options from the config and just override the severity.
-                             *
-                             * Example:
-                             *
-                             *   {
-                             *       rules: {
-                             *           curly: ["error", "multi"]
-                             *       }
-                             *   }
-                             *
-                             *   /* eslint curly: ["warn"] * /
-                             *
-                             *   Results in:
-                             *
-                             *   curly: ["warn", "multi"]
-                             */
+                                    /*
+                                     * And the rule was already configured
+                                     */
+                                    config.rules && Object.hasOwn(config.rules, ruleId)
+                                ) {
 
-                            let shouldValidateOptions = true;
+                                    /*
+                                     * Then use severity from the inline config and options from the provided config
+                                     */
+                                    ruleOptions = [
+                                        ruleOptions[0], // severity from the inline config
+                                        ...config.rules[ruleId].slice(1) // options from the provided config
+                                    ];
 
-                            if (
+                                    // if the rule was enabled, the options have already been validated
+                                    if (config.rules[ruleId][0] > 0) {
+                                        shouldValidateOptions = false;
+                                    }
+                                }
 
-                                /*
-                                 * If inline config for the rule has only severity
-                                 */
-                                ruleOptions.length === 1 &&
+                                if (shouldValidateOptions) {
+                                    ruleValidator.validate({
+                                        plugins: config.plugins,
+                                        rules: {
+                                            [ruleId]: ruleOptions
+                                        }
+                                    });
+                                }
 
-                                /*
-                                 * And the rule was already configured
-                                 */
-                                config.rules && Object.hasOwn(config.rules, ruleId)
-                            ) {
+                                mergedInlineConfig.rules[ruleId] = ruleOptions;
+                            } catch (err) {
 
                                 /*
-                                 * Then use severity from the inline config and options from the provided config
+                                 * If the rule has invalid `meta.schema`, throw the error because
+                                 * this is not an invalid inline configuration but an invalid rule.
                                  */
-                                ruleOptions = [
-                                    ruleOptions[0], // severity from the inline config
-                                    ...config.rules[ruleId].slice(1) // options from the provided config
-                                ];
-
-                                // if the rule was enabled, the options have already been validated
-                                if (config.rules[ruleId][0] > 0) {
-                                    shouldValidateOptions = false;
+                                if (err.code === "ESLINT_INVALID_RULE_OPTIONS_SCHEMA") {
+                                    throw err;
                                 }
-                            }
-
-                            if (shouldValidateOptions) {
-                                ruleValidator.validate({
-                                    plugins: config.plugins,
-                                    rules: {
-                                        [ruleId]: ruleOptions
-                                    }
-                                });
-                            }
 
-                            mergedInlineConfig.rules[ruleId] = ruleOptions;
-                        } catch (err) {
-
-                            /*
-                             * If the rule has invalid `meta.schema`, throw the error because
-                             * this is not an invalid inline configuration but an invalid rule.
-                             */
-                            if (err.code === "ESLINT_INVALID_RULE_OPTIONS_SCHEMA") {
-                                throw err;
-                            }
+                                let baseMessage = err.message.slice(
+                                    err.message.startsWith("Key \"rules\":")
+                                        ? err.message.indexOf(":", 12) + 1
+                                        : err.message.indexOf(":") + 1
+                                ).trim();
 
-                            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}".`;
+                                }
 
-                            if (err.messageTemplate) {
-                                baseMessage += ` You passed "${ruleValue}".`;
+                                inlineConfigProblems.push(createLintingProblem({
+                                    ruleId,
+                                    message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`,
+                                    loc,
+                                    language: config.language
+                                }));
                             }
-
-                            inlineConfigProblems.push(createLintingProblem({
-                                ruleId,
-                                message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`,
-                                loc: node.loc
-                            }));
-                        }
-                    });
+                        });
+                    }
                 }
             }
         }
@@ -1866,7 +1909,8 @@ class Linter {
         const commentDirectives = options.allowInlineConfig && !options.warnInlineConfig
             ? getDirectiveCommentsForFlatConfig(
                 sourceCode,
-                ruleId => getRuleFromConfig(ruleId, config)
+                ruleId => getRuleFromConfig(ruleId, config),
+                config.language
             )
             : { problems: [], disableDirectives: [] };
 
@@ -1874,7 +1918,7 @@ class Linter {
 
         let lintingProblems;
 
-        sourceCode.finalize();
+        sourceCode.finalize?.();
 
         try {
             lintingProblems = runRules(
@@ -1882,6 +1926,7 @@ class Linter {
                 configuredRules,
                 ruleId => getRuleFromConfig(ruleId, config),
                 void 0,
+                config.language,
                 languageOptions,
                 settings,
                 options.filename,
@@ -1915,6 +1960,7 @@ class Linter {
         }
 
         return applyDisableDirectives({
+            language: config.language,
             directives: commentDirectives.disableDirectives,
             disableFixes: options.disableFixes,
             problems: lintingProblems