eslint
diff --git a/‎lib/linter/report-translator.js renamed to ‎lib/linter/file-report.js
Copy file name to clipboard
+255-61Lines changed: 255 additions & 61 deletions b/‎lib/linter/report-translator.js renamed to ‎lib/linter/file-report.js
Copy file name to clipboard
+255-61Lines changed: 255 additions & 61 deletions
@@ -1,6 +1,6 @@
 /**
- * @fileoverview A helper that translates context.report() calls from the rule API into generic problem objects
- * @author Teddy Katz
+ * @fileoverview A class to track messages reported by the linter for a file.
+ * @author Nicholas C. Zakas
  */
 
 "use strict";
@@ -12,13 +12,16 @@
 const assert = require("../shared/assert");
 const { RuleFixer } = require("./rule-fixer");
 const { interpolate } = require("./interpolate");
+const ruleReplacements = require("../../conf/replacements.json");
 
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 
 /** @typedef {import("../types").Linter.LintMessage} LintMessage */
 /** @typedef {import("../types").Linter.LintSuggestion} SuggestionResult */
+/** @typedef {import("@eslint/core").Language} Language */
+/** @typedef {import("@eslint/core").SourceLocation} SourceLocation */
 
 /**
  * An error message description
@@ -32,10 +35,99 @@ const { interpolate } = require("./interpolate");
  * @property {Array<{desc?: string, messageId?: string, fix: Function}>} suggest Suggestion descriptions and functions to create a the associated fixes.
  */
 
+/**
+ * @typedef {Object} LintProblem
+ * @property {string} ruleId The rule ID that reported the problem.
+ * @property {string} message The problem message.
+ * @property {SourceLocation} loc The location of the problem.
+ */
+
 //------------------------------------------------------------------------------
-// Module Definition
+// Helpers
 //------------------------------------------------------------------------------
 
+const DEFAULT_ERROR_LOC = {
+	start: { line: 1, column: 0 },
+	end: { line: 1, column: 1 },
+};
+
+/**
+ * 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.
+ * @todo Potentially this should be moved into a shared utility file.
+ * @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 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.`;
+}
+
+/**
+ * creates a linting problem
+ * @param {LintProblem} options to create linting error
+ * @param {RuleSeverity} severity the error message to report
+ * @param {Language} 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, severity, language) {
+	const {
+		ruleId = null,
+		loc = DEFAULT_ERROR_LOC,
+		message = createMissingRuleMessage(options.ruleId),
+	} = 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,
+	};
+}
+
 /**
  * Translates a multi-argument context.report() call into a single object argument call
  * @param {...*} args A list of arguments passed to `context.report`
@@ -342,73 +434,175 @@ function validateSuggestions(suggest, messages) {
 }
 
 /**
- * Returns a function that converts the arguments of a `context.report` call from a rule into a reported
- * problem for the Node.js API.
- * @param {{ruleId: string, severity: number, sourceCode: SourceCode, messageIds: Object, disableFixes: boolean, language:Language}} metadata Metadata for the reported problem
- * @returns {function(...args): LintMessage} Function that returns information about the report
+ * Computes the message from a report descriptor.
+ * @param {MessageDescriptor} descriptor The report descriptor.
+ * @param {Object} messages Object of meta messages for the rule.
+ * @returns {string} The computed message.
+ * @throws {TypeError} If messageId is not found or both message and messageId are provided.
  */
+function computeMessageFromDescriptor(descriptor, messages) {
+	if (descriptor.messageId) {
+		if (!messages) {
+			throw new TypeError(
+				"context.report() called with a messageId, but no messages were present in the rule metadata.",
+			);
+		}
+		const id = descriptor.messageId;
 
-module.exports = function createReportTranslator(metadata) {
-	/*
-	 * `createReportTranslator` gets called once per enabled rule per file. It needs to be very performant.
-	 * The report translator itself (i.e. the function that `createReportTranslator` returns) gets
-	 * called every time a rule reports a problem, which happens much less frequently (usually, the vast
-	 * majority of rules don't report any problems for a given file).
+		if (descriptor.message) {
+			throw new TypeError(
+				"context.report() called with a message and a messageId. Please only pass one.",
+			);
+		}
+		if (!messages || !Object.hasOwn(messages, id)) {
+			throw new TypeError(
+				`context.report() called with a messageId of '${id}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`,
+			);
+		}
+		return messages[id];
+	}
+
+	if (descriptor.message) {
+		return descriptor.message;
+	}
+
+	throw new TypeError(
+		"Missing `message` property in report() call; add a message that describes the linting problem.",
+	);
+}
+
+/**
+ * A report object that contains the messages reported the linter
+ * for a file.
+ */
+class FileReport {
+	/**
+	 * The messages reported by the linter for this file.
+	 * @type {LintMessage[]}
+	 */
+	messages = [];
+
+	/**
+	 * A rule mapper that maps rule IDs to their metadata.
+	 * @type {(string) => RuleDefinition}
+	 */
+	#ruleMapper;
+
+	/**
+	 * The source code object for the file.
+	 * @type {SourceCode}
+	 */
+	#sourceCode;
+
+	/**
+	 * The language to use to adjust line and column offsets.
+	 * @type {Language}
+	 */
+	#language;
+
+	/**
+	 * Whether to disable fixes for this report.
+	 * @type {boolean}
 	 */
-	return (...args) => {
+	#disableFixes;
+
+	/**
+	 * Creates a new FileReport instance.
+	 * @param {Object} options The options for the file report
+	 * @param {(string) => RuleDefinition} options.ruleMapper A rule mapper that maps rule IDs to their metadata.
+	 * @param {SourceCode} options.sourceCode The source code object for the file.
+	 * @param {Language} options.language The language to use to adjust line and column offsets.
+	 * @param {boolean} [options.disableFixes=false] Whether to disable fixes for this report.
+	 */
+	constructor({ ruleMapper, sourceCode, language, disableFixes = false }) {
+		this.#ruleMapper = ruleMapper;
+		this.#sourceCode = sourceCode;
+		this.#language = language;
+		this.#disableFixes = disableFixes;
+	}
+
+	/**
+	 * Adds a rule-generated message to the report.
+	 * @param {string} ruleId The rule ID that reported the problem.
+	 * @param {0|1|2} severity The severity of the problem (0 = off, 1 = warning, 2 = error).
+	 * @param {...*} args The arguments passed to `context.report()`.
+	 * @returns {LintMessage} The created message object.
+	 * @throws {TypeError} If the messageId is not found or both message and messageId are provided.
+	 * @throws {AssertionError} If the node is not an object or neither a node nor a loc is provided.
+	 */
+	addRuleMessage(ruleId, severity, ...args) {
 		const descriptor = normalizeMultiArgReportCall(...args);
-		const messages = metadata.messageIds;
-		const { sourceCode } = metadata;
+		const ruleDefinition = this.#ruleMapper(ruleId);
+		const messages = ruleDefinition?.meta?.messages;
 
 		assertValidNodeInfo(descriptor);
 
-		let computedMessage;
+		const computedMessage = computeMessageFromDescriptor(
+			descriptor,
+			messages,
+		);
 
-		if (descriptor.messageId) {
-			if (!messages) {
-				throw new TypeError(
-					"context.report() called with a messageId, but no messages were present in the rule metadata.",
-				);
-			}
-			const id = descriptor.messageId;
+		validateSuggestions(descriptor.suggest, messages);
 
-			if (descriptor.message) {
-				throw new TypeError(
-					"context.report() called with a message and a messageId. Please only pass one.",
-				);
-			}
-			if (!messages || !Object.hasOwn(messages, id)) {
-				throw new TypeError(
-					`context.report() called with a messageId of '${id}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`,
-				);
-			}
-			computedMessage = messages[id];
-		} else if (descriptor.message) {
-			computedMessage = descriptor.message;
-		} else {
-			throw new TypeError(
-				"Missing `message` property in report() call; add a message that describes the linting problem.",
-			);
-		}
+		this.messages.push(
+			createProblem({
+				ruleId,
+				severity,
+				node: descriptor.node,
+				message: interpolate(computedMessage, descriptor.data),
+				messageId: descriptor.messageId,
+				loc: descriptor.loc
+					? normalizeReportLoc(descriptor)
+					: this.#sourceCode.getLoc(descriptor.node),
+				fix: this.#disableFixes
+					? null
+					: normalizeFixes(descriptor, this.#sourceCode),
+				suggestions: this.#disableFixes
+					? []
+					: mapSuggestions(descriptor, this.#sourceCode, messages),
+				language: this.#language,
+			}),
+		);
 
-		validateSuggestions(descriptor.suggest, messages);
+		return this.messages.at(-1);
+	}
 
-		return createProblem({
-			ruleId: metadata.ruleId,
-			severity: metadata.severity,
-			node: descriptor.node,
-			message: interpolate(computedMessage, descriptor.data),
-			messageId: descriptor.messageId,
-			loc: descriptor.loc
-				? normalizeReportLoc(descriptor)
-				: sourceCode.getLoc(descriptor.node),
-			fix: metadata.disableFixes
-				? null
-				: normalizeFixes(descriptor, sourceCode),
-			suggestions: metadata.disableFixes
-				? []
-				: mapSuggestions(descriptor, sourceCode, messages),
-			language: metadata.language,
-		});
-	};
+	/**
+	 * Adds an error message to the report. Meant to be called outside of rules.
+	 * @param {LintProblem} descriptor The descriptor for the error message.
+	 * @returns {LintMessage} The created message object.
+	 */
+	addError(descriptor) {
+		const message = createLintingProblem(descriptor, 2, this.#language);
+		this.messages.push(message);
+		return message;
+	}
+
+	/**
+	 * Adds a fatal error message to the report. Meant to be called outside of rules.
+	 * @param {LintProblem} descriptor The descriptor for the fatal error message.
+	 * @returns {LintMessage} The created message object.
+	 */
+	addFatal(descriptor) {
+		const message = createLintingProblem(descriptor, 2, this.#language);
+		message.fatal = true;
+		this.messages.push(message);
+		return message;
+	}
+
+	/**
+	 * Adds a warning message to the report. Meant to be called outside of rules.
+	 * @param {LintProblem} descriptor The descriptor for the warning message.
+	 * @returns {LintMessage} The created message object.
+	 */
+	addWarning(descriptor) {
+		const message = createLintingProblem(descriptor, 1, this.#language);
+		this.messages.push(message);
+		return message;
+	}
+}
+
+module.exports = {
+	FileReport,
+	updateLocationInformation,
 };