eslint 9.22.0 → 9.24.0

package/lib/linter/report-translator.js

@@ -35,39 +35,36 @@ const { interpolate } = require("./interpolate");
 // Module Definition
 //------------------------------------------------------------------------------
 
-
 /**
  * Translates a multi-argument context.report() call into a single object argument call
  * @param {...*} args A list of arguments passed to `context.report`
  * @returns {MessageDescriptor} A normalized object containing report information
  */
 function normalizeMultiArgReportCall(...args) {
-
-    // If there is one argument, it is considered to be a new-style call already.
-    if (args.length === 1) {
-
-        // Shallow clone the object to avoid surprises if reusing the descriptor
-        return Object.assign({}, args[0]);
-    }
-
-    // If the second argument is a string, the arguments are interpreted as [node, message, data, fix].
-    if (typeof args[1] === "string") {
-        return {
-            node: args[0],
-            message: args[1],
-            data: args[2],
-            fix: args[3]
-        };
-    }
-
-    // Otherwise, the arguments are interpreted as [node, loc, message, data, fix].
-    return {
-        node: args[0],
-        loc: args[1],
-        message: args[2],
-        data: args[3],
-        fix: args[4]
-    };
+	// If there is one argument, it is considered to be a new-style call already.
+	if (args.length === 1) {
+		// Shallow clone the object to avoid surprises if reusing the descriptor
+		return Object.assign({}, args[0]);
+	}
+
+	// If the second argument is a string, the arguments are interpreted as [node, message, data, fix].
+	if (typeof args[1] === "string") {
+		return {
+			node: args[0],
+			message: args[1],
+			data: args[2],
+			fix: args[3],
+		};
+	}
+
+	// Otherwise, the arguments are interpreted as [node, loc, message, data, fix].
+	return {
+		node: args[0],
+		loc: args[1],
+		message: args[2],
+		data: args[3],
+		fix: args[4],
+	};
 }
 
 /**
@@ -77,11 +74,14 @@ function normalizeMultiArgReportCall(...args) {
  * @throws AssertionError if neither a node nor a loc was provided, or if the node is not an object
  */
 function assertValidNodeInfo(descriptor) {
-    if (descriptor.node) {
-        assert(typeof descriptor.node === "object", "Node must be an object");
-    } else {
-        assert(descriptor.loc, "Node must be provided when reporting error if location is not provided");
-    }
+	if (descriptor.node) {
+		assert(typeof descriptor.node === "object", "Node must be an object");
+	} else {
+		assert(
+			descriptor.loc,
+			"Node must be provided when reporting error if location is not provided",
+		);
+	}
 }
 
 /**
@@ -91,10 +91,10 @@ function assertValidNodeInfo(descriptor) {
  * from the `node` of the original descriptor, or infers the `start` from the `loc` of the original descriptor.
  */
 function normalizeReportLoc(descriptor) {
-    if (descriptor.loc.start) {
-        return descriptor.loc;
-    }
-    return { start: descriptor.loc, end: null };
+	if (descriptor.loc.start) {
+		return descriptor.loc;
+	}
+	return { start: descriptor.loc, end: null };
 }
 
 /**
@@ -103,14 +103,14 @@ function normalizeReportLoc(descriptor) {
  * @returns {Fix|null} Deep cloned fix object or `null` if `null` or `undefined` was passed in.
  */
 function cloneFix(fix) {
-    if (!fix) {
-        return null;
-    }
-
-    return {
-        range: [fix.range[0], fix.range[1]],
-        text: fix.text
-    };
+	if (!fix) {
+		return null;
+	}
+
+	return {
+		range: [fix.range[0], fix.range[1]],
+		text: fix.text,
+	};
 }
 
 /**
@@ -119,9 +119,14 @@ function cloneFix(fix) {
  * @returns {void}
  */
 function assertValidFix(fix) {
-    if (fix) {
-        assert(fix.range && typeof fix.range[0] === "number" && typeof fix.range[1] === "number", `Fix has invalid range: ${JSON.stringify(fix, null, 2)}`);
-    }
+	if (fix) {
+		assert(
+			fix.range &&
+				typeof fix.range[0] === "number" &&
+				typeof fix.range[1] === "number",
+			`Fix has invalid range: ${JSON.stringify(fix, null, 2)}`,
+		);
+	}
 }
 
 /**
@@ -132,7 +137,7 @@ function assertValidFix(fix) {
  * @private
  */
 function compareFixesByRange(a, b) {
-    return a.range[0] - b.range[0] || a.range[1] - b.range[1];
+	return a.range[0] - b.range[0] || a.range[1] - b.range[1];
 }
 
 /**
@@ -142,37 +147,43 @@ function compareFixesByRange(a, b) {
  * @returns {{text: string, range: number[]}} The merged fixes
  */
 function mergeFixes(fixes, sourceCode) {
-    for (const fix of fixes) {
-        assertValidFix(fix);
-    }
-
-    if (fixes.length === 0) {
-        return null;
-    }
-    if (fixes.length === 1) {
-        return cloneFix(fixes[0]);
-    }
-
-    fixes.sort(compareFixesByRange);
-
-    const originalText = sourceCode.text;
-    const start = fixes[0].range[0];
-    const end = fixes.at(-1).range[1];
-    let text = "";
-    let lastPos = Number.MIN_SAFE_INTEGER;
-
-    for (const fix of fixes) {
-        assert(fix.range[0] >= lastPos, "Fix objects must not be overlapped in a report.");
-
-        if (fix.range[0] >= 0) {
-            text += originalText.slice(Math.max(0, start, lastPos), fix.range[0]);
-        }
-        text += fix.text;
-        lastPos = fix.range[1];
-    }
-    text += originalText.slice(Math.max(0, start, lastPos), end);
-
-    return { range: [start, end], text };
+	for (const fix of fixes) {
+		assertValidFix(fix);
+	}
+
+	if (fixes.length === 0) {
+		return null;
+	}
+	if (fixes.length === 1) {
+		return cloneFix(fixes[0]);
+	}
+
+	fixes.sort(compareFixesByRange);
+
+	const originalText = sourceCode.text;
+	const start = fixes[0].range[0];
+	const end = fixes.at(-1).range[1];
+	let text = "";
+	let lastPos = Number.MIN_SAFE_INTEGER;
+
+	for (const fix of fixes) {
+		assert(
+			fix.range[0] >= lastPos,
+			"Fix objects must not be overlapped in a report.",
+		);
+
+		if (fix.range[0] >= 0) {
+			text += originalText.slice(
+				Math.max(0, start, lastPos),
+				fix.range[0],
+			);
+		}
+		text += fix.text;
+		lastPos = fix.range[1];
+	}
+	text += originalText.slice(Math.max(0, start, lastPos), end);
+
+	return { range: [start, end], text };
 }
 
 /**
@@ -183,22 +194,22 @@ function mergeFixes(fixes, sourceCode) {
  * @returns {({text: string, range: number[]}|null)} The fix for the descriptor
  */
 function normalizeFixes(descriptor, sourceCode) {
-    if (typeof descriptor.fix !== "function") {
-        return null;
-    }
+	if (typeof descriptor.fix !== "function") {
+		return null;
+	}
 
-    const ruleFixer = new RuleFixer({ sourceCode });
+	const ruleFixer = new RuleFixer({ sourceCode });
 
-    // @type {null | Fix | Fix[] | IterableIterator<Fix>}
-    const fix = descriptor.fix(ruleFixer);
+	// @type {null | Fix | Fix[] | IterableIterator<Fix>}
+	const fix = descriptor.fix(ruleFixer);
 
-    // Merge to one.
-    if (fix && Symbol.iterator in fix) {
-        return mergeFixes(Array.from(fix), sourceCode);
-    }
+	// Merge to one.
+	if (fix && Symbol.iterator in fix) {
+		return mergeFixes(Array.from(fix), sourceCode);
+	}
 
-    assertValidFix(fix);
-    return cloneFix(fix);
+	assertValidFix(fix);
+	return cloneFix(fix);
 }
 
 /**
@@ -209,23 +220,26 @@ function normalizeFixes(descriptor, sourceCode) {
  * @returns {Array<SuggestionResult>} The suggestions for the descriptor
  */
 function mapSuggestions(descriptor, sourceCode, messages) {
-    if (!descriptor.suggest || !Array.isArray(descriptor.suggest)) {
-        return [];
-    }
-
-    return descriptor.suggest
-        .map(suggestInfo => {
-            const computedDesc = suggestInfo.desc || messages[suggestInfo.messageId];
-
-            return {
-                ...suggestInfo,
-                desc: interpolate(computedDesc, suggestInfo.data),
-                fix: normalizeFixes(suggestInfo, sourceCode)
-            };
-        })
-
-        // Remove suggestions that didn't provide a fix
-        .filter(({ fix }) => fix);
+	if (!descriptor.suggest || !Array.isArray(descriptor.suggest)) {
+		return [];
+	}
+
+	return (
+		descriptor.suggest
+			.map(suggestInfo => {
+				const computedDesc =
+					suggestInfo.desc || messages[suggestInfo.messageId];
+
+				return {
+					...suggestInfo,
+					desc: interpolate(computedDesc, suggestInfo.data),
+					fix: normalizeFixes(suggestInfo, sourceCode),
+				};
+			})
+
+			// Remove suggestions that didn't provide a fix
+			.filter(({ fix }) => fix)
+	);
 }
 
 /**
@@ -243,43 +257,43 @@ function mapSuggestions(descriptor, sourceCode, messages) {
  * @returns {LintMessage} Information about the report
  */
 function createProblem(options) {
-    const { language } = options;
-
-    // calculate offsets based on the language in use
-    const columnOffset = language.columnStart === 1 ? 0 : 1;
-    const lineOffset = language.lineStart === 1 ? 0 : 1;
-
-    const problem = {
-        ruleId: options.ruleId,
-        severity: options.severity,
-        message: options.message,
-        line: options.loc.start.line + lineOffset,
-        column: options.loc.start.column + columnOffset,
-        nodeType: options.node && options.node.type || null
-    };
-
-    /*
-     * If this isn’t in the conditional, some of the tests fail
-     * because `messageId` is present in the problem object
-     */
-    if (options.messageId) {
-        problem.messageId = options.messageId;
-    }
-
-    if (options.loc.end) {
-        problem.endLine = options.loc.end.line + lineOffset;
-        problem.endColumn = options.loc.end.column + columnOffset;
-    }
-
-    if (options.fix) {
-        problem.fix = options.fix;
-    }
-
-    if (options.suggestions && options.suggestions.length > 0) {
-        problem.suggestions = options.suggestions;
-    }
-
-    return problem;
+	const { language } = options;
+
+	// calculate offsets based on the language in use
+	const columnOffset = language.columnStart === 1 ? 0 : 1;
+	const lineOffset = language.lineStart === 1 ? 0 : 1;
+
+	const problem = {
+		ruleId: options.ruleId,
+		severity: options.severity,
+		message: options.message,
+		line: options.loc.start.line + lineOffset,
+		column: options.loc.start.column + columnOffset,
+		nodeType: (options.node && options.node.type) || null,
+	};
+
+	/*
+	 * If this isn’t in the conditional, some of the tests fail
+	 * because `messageId` is present in the problem object
+	 */
+	if (options.messageId) {
+		problem.messageId = options.messageId;
+	}
+
+	if (options.loc.end) {
+		problem.endLine = options.loc.end.line + lineOffset;
+		problem.endColumn = options.loc.end.column + columnOffset;
+	}
+
+	if (options.fix) {
+		problem.fix = options.fix;
+	}
+
+	if (options.suggestions && options.suggestions.length > 0) {
+		problem.suggestions = options.suggestions;
+	}
+
+	return problem;
 }
 
 /**
@@ -289,31 +303,41 @@ function createProblem(options) {
  * @returns {void}
  */
 function validateSuggestions(suggest, messages) {
-    if (suggest && Array.isArray(suggest)) {
-        suggest.forEach(suggestion => {
-            if (suggestion.messageId) {
-                const { messageId } = suggestion;
-
-                if (!messages) {
-                    throw new TypeError(`context.report() called with a suggest option with a messageId '${messageId}', but no messages were present in the rule metadata.`);
-                }
-
-                if (!messages[messageId]) {
-                    throw new TypeError(`context.report() called with a suggest option with a messageId '${messageId}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`);
-                }
-
-                if (suggestion.desc) {
-                    throw new TypeError("context.report() called with a suggest option that defines both a 'messageId' and an 'desc'. Please only pass one.");
-                }
-            } else if (!suggestion.desc) {
-                throw new TypeError("context.report() called with a suggest option that doesn't have either a `desc` or `messageId`");
-            }
-
-            if (typeof suggestion.fix !== "function") {
-                throw new TypeError(`context.report() called with a suggest option without a fix function. See: ${suggestion}`);
-            }
-        });
-    }
+	if (suggest && Array.isArray(suggest)) {
+		suggest.forEach(suggestion => {
+			if (suggestion.messageId) {
+				const { messageId } = suggestion;
+
+				if (!messages) {
+					throw new TypeError(
+						`context.report() called with a suggest option with a messageId '${messageId}', but no messages were present in the rule metadata.`,
+					);
+				}
+
+				if (!messages[messageId]) {
+					throw new TypeError(
+						`context.report() called with a suggest option with a messageId '${messageId}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`,
+					);
+				}
+
+				if (suggestion.desc) {
+					throw new TypeError(
+						"context.report() called with a suggest option that defines both a 'messageId' and an 'desc'. Please only pass one.",
+					);
+				}
+			} else if (!suggestion.desc) {
+				throw new TypeError(
+					"context.report() called with a suggest option that doesn't have either a `desc` or `messageId`",
+				);
+			}
+
+			if (typeof suggestion.fix !== "function") {
+				throw new TypeError(
+					`context.report() called with a suggest option without a fix function. See: ${suggestion}`,
+				);
+			}
+		});
+	}
 }
 
 /**
@@ -324,53 +348,66 @@ function validateSuggestions(suggest, messages) {
  */
 
 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).
-     */
-    return (...args) => {
-        const descriptor = normalizeMultiArgReportCall(...args);
-        const messages = metadata.messageIds;
-        const { sourceCode } = metadata;
-
-        assertValidNodeInfo(descriptor);
-
-        let computedMessage;
-
-        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;
-
-            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.");
-        }
-
-        validateSuggestions(descriptor.suggest, messages);
-
-        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
-        });
-    };
+	/*
+	 * `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).
+	 */
+	return (...args) => {
+		const descriptor = normalizeMultiArgReportCall(...args);
+		const messages = metadata.messageIds;
+		const { sourceCode } = metadata;
+
+		assertValidNodeInfo(descriptor);
+
+		let computedMessage;
+
+		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;
+
+			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.",
+			);
+		}
+
+		validateSuggestions(descriptor.suggest, messages);
+
+		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,
+		});
+	};
 };