eslint 9.31.0 → 9.33.0

package/lib/linter/linter.js

@@ -27,12 +27,10 @@ const path = require("node:path"),
 	{ SourceCode } = require("../languages/js/source-code"),
 	applyDisableDirectives = require("./apply-disable-directives"),
 	{ ConfigCommentParser } = require("@eslint/plugin-kit"),
-	createReportTranslator = require("./report-translator"),
 	Rules = require("./rules"),
 	SourceCodeFixer = require("./source-code-fixer"),
 	{ SourceCodeVisitor } = require("./source-code-visitor"),
-	timing = require("./timing"),
-	ruleReplacements = require("../../conf/replacements.json");
+	timing = require("./timing");
 const { FlatConfigArray } = require("../config/flat-config-array");
 const { startTime, endTime } = require("../shared/stats");
 const { assertIsRuleSeverity } = require("../config/flat-config-schema");
@@ -52,10 +50,6 @@ const MAX_AUTOFIX_PASSES = 10;
 const DEFAULT_PARSER_NAME = "espree";
 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 { LATEST_ECMA_VERSION } = require("../../conf/ecma-version");
 const { VFile } = require("./vfile");
@@ -66,6 +60,7 @@ const { containsDifferentProperty } = require("../shared/option-utils");
 const { Config } = require("../config/config");
 const { WarningService } = require("../services/warning-service");
 const { SourceCodeTraverser } = require("./source-code-traverser");
+const { FileReport, updateLocationInformation } = require("./file-report");
 
 //------------------------------------------------------------------------------
 // Typedefs
@@ -253,92 +248,6 @@ function addDeclaredGlobals(
 	});
 }
 
-/**
- * creates a missing-rule message.
- * @param {string} ruleId the ruleId to create
- * @returns {string} created error message
- * @private
- */
-function createMissingRuleMessage(ruleId) {
-	return Object.hasOwn(ruleReplacements.rules, ruleId)
-		? `Rule '${ruleId}' was removed and replaced by: ${ruleReplacements.rules[ruleId].join(", ")}`
-		: `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 {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
- */
-function createLintingProblem(options) {
-	const {
-		ruleId = null,
-		loc = DEFAULT_ERROR_LOC,
-		message = createMissingRuleMessage(options.ruleId),
-		severity = 2,
-
-		// fallback for eslintrc mode
-		language = {
-			columnStart: 0,
-			lineStart: 1,
-		},
-	} = options;
-
-	return {
-		ruleId,
-		message,
-		...updateLocationInformation(
-			{
-				line: loc.start.line,
-				column: loc.start.column,
-				endLine: loc.end.line,
-				endColumn: loc.end.column,
-			},
-			language,
-		),
-		severity,
-		nodeType: null,
-	};
-}
-
 /**
  * Wraps the value in an Array if it isn't already one.
  * @template T
@@ -353,7 +262,7 @@ function asArray(value) {
  * Pushes a problem to inlineConfigProblems if ruleOptions are redundant.
  * @param {Config} config Provided config.
  * @param {Object} loc A line/column location
- * @param {Array} problems Problems that may be added to.
+ * @param {FileReport} report Report that may be added to.
  * @param {string} ruleId The rule ID.
  * @param {Array} ruleOptions The rule options, merged with the config's.
  * @param {Array} ruleOptionsInline The rule options from the comment.
@@ -363,7 +272,7 @@ function asArray(value) {
 function addProblemIfSameSeverityAndOptions(
 	config,
 	loc,
-	problems,
+	report,
 	ruleId,
 	ruleOptions,
 	ruleOptionsInline,
@@ -404,15 +313,17 @@ function addProblemIfSameSeverityAndOptions(
 	}
 
 	if (message) {
-		problems.push(
-			createLintingProblem({
-				ruleId: null,
-				message,
-				loc,
-				language: config.language,
-				severity: normalizeSeverityToNumber(severity),
-			}),
-		);
+		const numericSeverity = normalizeSeverityToNumber(severity);
+		const descriptor = {
+			message,
+			loc,
+		};
+
+		if (numericSeverity === 1) {
+			report.addWarning(descriptor);
+		} else if (numericSeverity === 2) {
+			report.addError(descriptor);
+		}
 	}
 }
 
@@ -427,20 +338,19 @@ function addProblemIfSameSeverityAndOptions(
  * @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.
  * @param {SourceCode} sourceCode The SourceCode object to get comments from.
- * @returns {Object} Directives and problems from the comment
+ * @param {FileReport} report The report to add problems to.
+ * @returns {Object[]} Directives from the comment
  */
 function createDisableDirectives(
 	{ type, value, justification, node },
 	ruleMapper,
 	language,
 	sourceCode,
+	report,
 ) {
 	const ruleIds = Object.keys(commentParser.parseListConfig(value));
 	const directiveRules = ruleIds.length ? ruleIds : [null];
-	const result = {
-		directives: [], // valid disable directives
-		directiveProblems: [], // problems in directives
-	};
+	const directives = []; // valid disable directives
 	const parentDirective = { node, value, ruleIds };
 
 	for (const ruleId of directiveRules) {
@@ -454,7 +364,7 @@ function createDisableDirectives(
 					language,
 				);
 
-				result.directives.push({
+				directives.push({
 					parentDirective,
 					type,
 					line,
@@ -468,7 +378,7 @@ function createDisableDirectives(
 					language,
 				);
 
-				result.directives.push({
+				directives.push({
 					parentDirective,
 					type,
 					line,
@@ -478,12 +388,11 @@ function createDisableDirectives(
 				});
 			}
 		} else {
-			result.directiveProblems.push(
-				createLintingProblem({ ruleId, loc, language }),
-			);
+			report.addError({ ruleId, loc });
 		}
 	}
-	return result;
+
+	return directives;
 }
 
 /**
@@ -494,7 +403,8 @@ function createDisableDirectives(
  * @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.
  * @param {ConfigData} config Provided config.
- * @returns {{configuredRules: Object, enabledGlobals: {value:string,comment:Token}[], exportedVariables: Object, problems: LintMessage[], disableDirectives: DisableDirective[]}}
+ * @param {FileReport} report The report to add problems to.
+ * @returns {{configuredRules: Object, enabledGlobals: {value:string,comment:Token}[], exportedVariables: Object, disableDirectives: DisableDirective[]}}
  * A collection of the directive comments that were found, along with any problems that occurred when parsing
  */
 function getDirectiveComments(
@@ -502,11 +412,11 @@ function getDirectiveComments(
 	ruleMapper,
 	warnInlineConfig,
 	config,
+	report,
 ) {
 	const configuredRules = {};
 	const enabledGlobals = Object.create(null);
 	const exportedVariables = {};
-	const problems = [];
 	const disableDirectives = [];
 	const validator = new ConfigValidator({
 		builtInRules: Rules,
@@ -542,14 +452,11 @@ function getDirectiveComments(
 				const kind =
 					comment.type === "Block" ? `/*${label}*/` : `//${label}`;
 
-				problems.push(
-					createLintingProblem({
-						ruleId: null,
-						message: `'${kind}' has no effect because you have 'noInlineConfig' setting in ${warnInlineConfig}.`,
-						loc,
-						severity: 1,
-					}),
-				);
+				report.addWarning({
+					ruleId: null,
+					message: `'${kind}' has no effect because you have 'noInlineConfig' setting in ${warnInlineConfig}.`,
+					loc,
+				});
 				return;
 			}
 
@@ -559,13 +466,10 @@ function getDirectiveComments(
 			) {
 				const message = `${label} comment should not span multiple lines.`;
 
-				problems.push(
-					createLintingProblem({
-						ruleId: null,
-						message,
-						loc,
-					}),
-				);
+				report.addError({
+					message,
+					loc,
+				});
 				return;
 			}
 
@@ -575,21 +479,20 @@ function getDirectiveComments(
 				case "eslint-disable-next-line":
 				case "eslint-disable-line": {
 					const directiveType = label.slice("eslint-".length);
-					const { directives, directiveProblems } =
-						createDisableDirectives(
-							{
-								type: directiveType,
-								value,
-								justification: justificationPart,
-								node: comment,
-							},
-							ruleMapper,
-							jslang,
-							sourceCode,
-						);
+					const directives = createDisableDirectives(
+						{
+							type: directiveType,
+							value,
+							justification: justificationPart,
+							node: comment,
+						},
+						ruleMapper,
+						jslang,
+						sourceCode,
+						report,
+					);
 
 					disableDirectives.push(...directives);
-					problems.push(...directiveProblems);
 					break;
 				}
 
@@ -611,13 +514,10 @@ function getDirectiveComments(
 							normalizedValue =
 								ConfigOps.normalizeConfigGlobal(idSetting);
 						} catch (err) {
-							problems.push(
-								createLintingProblem({
-									ruleId: null,
-									loc,
-									message: err.message,
-								}),
-							);
+							report.addError({
+								loc,
+								message: err.message,
+							});
 							continue;
 						}
 
@@ -643,19 +543,15 @@ function getDirectiveComments(
 							const ruleValue = parseResult.config[name];
 
 							if (!rule) {
-								problems.push(
-									createLintingProblem({ ruleId: name, loc }),
-								);
+								report.addError({ ruleId: name, loc });
 								return;
 							}
 
 							if (Object.hasOwn(configuredRules, name)) {
-								problems.push(
-									createLintingProblem({
-										message: `Rule "${name}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
-										loc,
-									}),
-								);
+								report.addError({
+									message: `Rule "${name}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
+									loc,
+								});
 								return;
 							}
 
@@ -717,13 +613,11 @@ function getDirectiveComments(
 									throw err;
 								}
 
-								problems.push(
-									createLintingProblem({
-										ruleId: name,
-										message: err.message,
-										loc,
-									}),
-								);
+								report.addError({
+									ruleId: name,
+									message: err.message,
+									loc,
+								});
 
 								// do not apply the config, if found invalid options.
 								return;
@@ -732,14 +626,10 @@ function getDirectiveComments(
 							configuredRules[name] = ruleOptions;
 						});
 					} else {
-						const problem = createLintingProblem({
-							ruleId: null,
+						report.addFatal({
 							loc,
 							message: parseResult.error.message,
 						});
-
-						problem.fatal = true;
-						problems.push(problem);
 					}
 
 					break;
@@ -753,7 +643,6 @@ function getDirectiveComments(
 		configuredRules,
 		enabledGlobals,
 		exportedVariables,
-		problems,
 		disableDirectives,
 	};
 }
@@ -763,43 +652,40 @@ function getDirectiveComments(
  * @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[]}}
+ * @param {FileReport} report The report to add problems to.
+ * @returns {DisableDirective[]}
  * A collection of the directive comments that were found, along with any problems that occurred when parsing
  */
-function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper, language) {
+function getDirectiveCommentsForFlatConfig(
+	sourceCode,
+	ruleMapper,
+	language,
+	report,
+) {
 	const disableDirectives = [];
-	const problems = [];
 
 	if (sourceCode.getDisableDirectives) {
 		const { directives: directivesSources, problems: directivesProblems } =
 			sourceCode.getDisableDirectives();
 
-		problems.push(
-			...directivesProblems.map(directiveProblem =>
-				createLintingProblem({
-					...directiveProblem,
-					language,
-				}),
-			),
-		);
+		if (Array.isArray(directivesProblems)) {
+			directivesProblems.forEach(problem => report.addError(problem));
+		}
 
 		directivesSources.forEach(directive => {
-			const { directives, directiveProblems } = createDisableDirectives(
+			const directives = createDisableDirectives(
 				directive,
 				ruleMapper,
 				language,
 				sourceCode,
+				report,
 			);
 
 			disableDirectives.push(...directives);
-			problems.push(...directiveProblems);
 		});
 	}
 
-	return {
-		problems,
-		disableDirectives,
-	};
+	return disableDirectives;
 }
 
 /**
@@ -1149,13 +1035,13 @@ function createRuleListeners(rule, ruleContext) {
  * @param {Object} settings The settings that were enabled in the config
  * @param {string} filename The reported filename of the code
  * @param {boolean} applyDefaultOptions If true, apply rules' meta.defaultOptions in computing their config options.
- * @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
  * @param {Function} ruleFilter A predicate function to filter which rules should be executed.
  * @param {boolean} stats If true, stats are collected appended to the result
  * @param {WeakMap<Linter, LinterInternalSlots>} slots InternalSlotsMap of linter
- * @returns {LintMessage[]} An array of reported problems
+ * @param {FileReport} report The report to add problems to
+ * @returns {FileReport} report The report with added problems
  * @throws {Error} If traversal into a node fails.
  */
 function runRules(
@@ -1168,12 +1054,12 @@ function runRules(
 	settings,
 	filename,
 	applyDefaultOptions,
-	disableFixes,
 	cwd,
 	physicalFilename,
 	ruleFilter,
 	stats,
 	slots,
+	report,
 ) {
 	const visitor = new SourceCodeVisitor();
 
@@ -1195,7 +1081,6 @@ function runRules(
 		settings,
 	});
 
-	const lintingProblems = [];
 	const steps = sourceCode.traverse();
 
 	Object.keys(configuredRules).forEach(ruleId => {
@@ -1213,12 +1098,10 @@ function runRules(
 		const rule = ruleMapper(ruleId);
 
 		if (!rule) {
-			lintingProblems.push(createLintingProblem({ ruleId, language }));
+			report.addError({ ruleId });
 			return;
 		}
 
-		const messageIds = rule.meta && rule.meta.messages;
-		let reportTranslator = null;
 		const ruleContext = fileContext.extend({
 			id: ruleId,
 			options: getRuleOptions(
@@ -1226,33 +1109,18 @@ function runRules(
 				applyDefaultOptions ? rule.meta?.defaultOptions : void 0,
 			),
 			report(...args) {
-				/*
-				 * Create a report translator lazily.
-				 * In a vast majority of cases, any given rule reports zero errors on a given
-				 * piece of code. Creating a translator lazily avoids the performance cost of
-				 * creating a new translator function for each rule that usually doesn't get
-				 * called.
-				 *
-				 * Using lazy report translators improves end-to-end performance by about 3%
-				 * with Node 8.4.0.
-				 */
-				if (reportTranslator === null) {
-					reportTranslator = createReportTranslator({
-						ruleId,
-						severity,
-						sourceCode,
-						messageIds,
-						disableFixes,
-						language,
-					});
-				}
-				const problem = reportTranslator(...args);
+				const problem = report.addRuleMessage(
+					ruleId,
+					severity,
+					...args,
+				);
 
 				if (problem.fix && !(rule.meta && rule.meta.fixable)) {
 					throw new Error(
 						'Fixable rules must set the `meta.fixable` property to "code" or "whitespace".',
 					);
 				}
+
 				if (
 					problem.suggestions &&
 					!(rule.meta && rule.meta.hasSuggestions === true)
@@ -1271,7 +1139,6 @@ function runRules(
 						"Rules with suggestions must set the `meta.hasSuggestions` property to `true`.",
 					);
 				}
-				lintingProblems.push(problem);
 			},
 		});
 
@@ -1347,7 +1214,7 @@ function runRules(
 
 	traverser.traverseSync(sourceCode, visitor, { steps });
 
-	return lintingProblems;
+	return report;
 }
 
 /**
@@ -1636,18 +1503,25 @@ class Linter {
 		}
 
 		const sourceCode = slots.lastSourceCode;
+		const report = new FileReport({
+			ruleMapper: ruleId => getRule(slots, ruleId),
+			language: jslang,
+			sourceCode,
+			disableFixes: options.disableFixes,
+		});
+
 		const commentDirectives = options.allowInlineConfig
 			? getDirectiveComments(
 					sourceCode,
 					ruleId => getRule(slots, ruleId),
 					options.warnInlineConfig,
 					config,
+					report,
 				)
 			: {
 					configuredRules: {},
 					enabledGlobals: {},
 					exportedVariables: {},
-					problems: [],
 					disableDirectives: [],
 				};
 
@@ -1666,10 +1540,8 @@ class Linter {
 			commentDirectives.configuredRules,
 		);
 
-		let lintingProblems;
-
 		try {
-			lintingProblems = runRules(
+			runRules(
 				sourceCode,
 				configuredRules,
 				ruleId => getRule(slots, ruleId),
@@ -1679,12 +1551,12 @@ class Linter {
 				settings,
 				options.filename,
 				true,
-				options.disableFixes,
 				slots.cwd,
 				providedOptions.physicalFilename,
 				null,
 				options.stats,
 				slots,
+				report,
 			);
 		} catch (err) {
 			err.message += `\nOccurred while linting ${options.filename}`;
@@ -1712,13 +1584,11 @@ class Linter {
 			sourceCode,
 			directives: commentDirectives.disableDirectives,
 			disableFixes: options.disableFixes,
-			problems: lintingProblems
-				.concat(commentDirectives.problems)
-				.sort(
-					(problemA, problemB) =>
-						problemA.line - problemB.line ||
-						problemA.column - problemB.column,
-				),
+			problems: report.messages.sort(
+				(problemA, problemB) =>
+					problemA.line - problemB.line ||
+					problemA.column - problemB.column,
+			),
 			reportUnusedDisableDirectives:
 				options.reportUnusedDisableDirectives,
 		});
@@ -2013,6 +1883,12 @@ class Linter {
 		}
 
 		const sourceCode = slots.lastSourceCode;
+		const report = new FileReport({
+			ruleMapper: ruleId => config.getRuleDefinition(ruleId),
+			language: config.language,
+			sourceCode,
+			disableFixes: options.disableFixes,
+		});
 
 		/*
 		 * Make adjustments based on the language options. For JavaScript,
@@ -2024,7 +1900,6 @@ class Linter {
 		const mergedInlineConfig = {
 			rules: {},
 		};
-		const inlineConfigProblems = [];
 
 		/*
 		 * Inline config can be either enabled or disabled. If disabled, it's possible
@@ -2040,34 +1915,19 @@ class Linter {
 						const loc = sourceCode.getLoc(node);
 						const range = sourceCode.getRange(node);
 
-						inlineConfigProblems.push(
-							createLintingProblem({
-								ruleId: null,
-								message: `'${sourceCode.text.slice(range[0], range[1])}' has no effect because you have 'noInlineConfig' setting in ${options.warnInlineConfig}.`,
-								loc,
-								severity: 1,
-								language: config.language,
-							}),
-						);
+						report.addWarning({
+							message: `'${sourceCode.text.slice(range[0], range[1])}' has no effect because you have 'noInlineConfig' setting in ${options.warnInlineConfig}.`,
+							loc,
+						});
 					});
 				}
 			} else {
 				const inlineConfigResult = sourceCode.applyInlineConfig?.();
 
 				if (inlineConfigResult) {
-					inlineConfigProblems.push(
-						...inlineConfigResult.problems
-							.map(problem =>
-								createLintingProblem({
-									...problem,
-									language: config.language,
-								}),
-							)
-							.map(problem => {
-								problem.fatal = true;
-								return problem;
-							}),
-					);
+					inlineConfigResult.problems.forEach(problem => {
+						report.addFatal(problem);
+					});
 
 					for (const {
 						config: inlineConfig,
@@ -2078,26 +1938,20 @@ class Linter {
 							const ruleValue = inlineConfig.rules[ruleId];
 
 							if (!rule) {
-								inlineConfigProblems.push(
-									createLintingProblem({
-										ruleId,
-										loc,
-										language: config.language,
-									}),
-								);
+								report.addError({
+									ruleId,
+									loc,
+								});
 								return;
 							}
 
 							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,
-									}),
-								);
+								report.addError({
+									message: `Rule "${ruleId}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
+									loc,
+								});
 								return;
 							}
 
@@ -2175,7 +2029,7 @@ class Linter {
 									addProblemIfSameSeverityAndOptions(
 										config,
 										loc,
-										inlineConfigProblems,
+										report,
 										ruleId,
 										ruleOptions,
 										ruleOptionsInline,
@@ -2214,14 +2068,11 @@ class Linter {
 									baseMessage += ` You passed "${ruleValue}".`;
 								}
 
-								inlineConfigProblems.push(
-									createLintingProblem({
-										ruleId,
-										message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`,
-										loc,
-										language: config.language,
-									}),
-								);
+								report.addError({
+									ruleId,
+									message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`,
+									loc,
+								});
 							}
 						});
 					}
@@ -2235,8 +2086,9 @@ class Linter {
 						sourceCode,
 						ruleId => config.getRuleDefinition(ruleId),
 						config.language,
+						report,
 					)
-				: { problems: [], disableDirectives: [] };
+				: [];
 
 		const configuredRules = Object.assign(
 			{},
@@ -2244,12 +2096,10 @@ class Linter {
 			mergedInlineConfig.rules,
 		);
 
-		let lintingProblems;
-
 		sourceCode.finalize?.();
 
 		try {
-			lintingProblems = runRules(
+			runRules(
 				sourceCode,
 				configuredRules,
 				ruleId => config.getRuleDefinition(ruleId),
@@ -2259,12 +2109,12 @@ class Linter {
 				settings,
 				options.filename,
 				false,
-				options.disableFixes,
 				slots.cwd,
 				providedOptions.physicalFilename,
 				options.ruleFilter,
 				options.stats,
 				slots,
+				report,
 			);
 		} catch (err) {
 			err.message += `\nOccurred while linting ${options.filename}`;
@@ -2291,16 +2141,13 @@ class Linter {
 		return applyDisableDirectives({
 			language: config.language,
 			sourceCode,
-			directives: commentDirectives.disableDirectives,
+			directives: commentDirectives,
 			disableFixes: options.disableFixes,
-			problems: lintingProblems
-				.concat(commentDirectives.problems)
-				.concat(inlineConfigProblems)
-				.sort(
-					(problemA, problemB) =>
-						problemA.line - problemB.line ||
-						problemA.column - problemB.column,
-				),
+			problems: report.messages.sort(
+				(problemA, problemB) =>
+					problemA.line - problemB.line ||
+					problemA.column - problemB.column,
+			),
 			reportUnusedDisableDirectives:
 				options.reportUnusedDisableDirectives,
 			ruleFilter: options.ruleFilter,