bahlint 28.58.6934

package/lib/services/suppressions-service.js

@@ -0,0 +1,302 @@
+/**
+ * @fileoverview Manages the suppressed violations.
+ * @author Iacovos Constantinou
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { calculateStatsPerFile } = require("../eslint/eslint-helpers");
+const stringify = require("json-stable-stringify-without-jsonify");
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+// For VSCode IntelliSense
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
+/** @typedef {Record<string, Record<string, { count: number; }>>} SuppressedViolations */
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * Manages the suppressed violations.
+ */
+class SuppressionsService {
+	filePath = "";
+	cwd = "";
+
+	/**
+	 * Creates a new instance of SuppressionsService.
+	 * @param {Object} options The options.
+	 * @param {string} [options.filePath] The location of the suppressions file.
+	 * @param {string} [options.cwd] The current working directory.
+	 */
+	constructor({ filePath, cwd }) {
+		this.filePath = filePath;
+		this.cwd = cwd;
+	}
+
+	/**
+	 * Updates the suppressions file based on the current violations and the provided rules.
+	 * If no rules are provided, all violations are suppressed.
+	 * @param {LintResult[]|undefined} results The lint results.
+	 * @param {string[]|undefined} rules The rules to suppress.
+	 * @returns {Promise<void>}
+	 */
+	async suppress(results, rules) {
+		const suppressions = await this.load();
+
+		for (const result of results) {
+			const relativeFilePath = this.getRelativeFilePath(result.filePath);
+			const violationsByRule = SuppressionsService.countViolationsByRule(
+				result.messages,
+			);
+
+			for (const ruleId in violationsByRule) {
+				if (rules && !rules.includes(ruleId)) {
+					continue;
+				}
+
+				suppressions[relativeFilePath] ??= {};
+				suppressions[relativeFilePath][ruleId] =
+					violationsByRule[ruleId];
+			}
+		}
+
+		return this.save(suppressions);
+	}
+
+	/**
+	 * Removes old, unused suppressions for violations that do not occur anymore.
+	 * @param {LintResult[]} results The lint results.
+	 * @returns {Promise<void>} No return value.
+	 */
+	async prune(results) {
+		const suppressions = await this.load();
+		const { unused } = this.applySuppressions(results, suppressions);
+
+		for (const file in unused) {
+			if (!suppressions[file]) {
+				continue;
+			}
+
+			for (const rule in unused[file]) {
+				if (!suppressions[file][rule]) {
+					continue;
+				}
+
+				const suppressionsCount = suppressions[file][rule].count;
+				const violationsCount = unused[file][rule].count;
+
+				if (suppressionsCount === violationsCount) {
+					// Remove unused rules
+					delete suppressions[file][rule];
+				} else {
+					// Update the count to match the new number of violations
+					suppressions[file][rule].count -= violationsCount;
+				}
+			}
+
+			// Cleanup files with no rules
+			if (Object.keys(suppressions[file]).length === 0) {
+				delete suppressions[file];
+			}
+		}
+
+		for (const file of Object.keys(suppressions)) {
+			const absolutePath = path.resolve(this.cwd, file);
+
+			if (!fs.existsSync(absolutePath)) {
+				delete suppressions[file];
+			}
+		}
+
+		return this.save(suppressions);
+	}
+
+	/**
+	 * Checks the provided suppressions against the lint results.
+	 *
+	 * For each file, counts the number of violations per rule.
+	 * For each rule in each file, compares the number of violations against the counter from the suppressions file.
+	 * If the number of violations is less or equal to the counter, messages are moved to `LintResult#suppressedMessages` and ignored.
+	 * Otherwise, all violations are reported as usual.
+	 * @param {LintResult[]} results The lint results.
+	 * @param {SuppressedViolations} suppressions The suppressions.
+	 * @returns {{
+	 *   results: LintResult[],
+	 *   unused: SuppressedViolations
+	 * }} The updated results and the unused suppressions.
+	 */
+	applySuppressions(results, suppressions) {
+		/**
+		 * We copy the results to avoid modifying the original objects
+		 * We remove only result messages that are matched and hence suppressed
+		 * We leave the rest untouched to minimize the risk of losing parts of the original data
+		 */
+		const filtered = structuredClone(results);
+		const unused = {};
+
+		for (const result of filtered) {
+			const relativeFilePath = this.getRelativeFilePath(result.filePath);
+
+			if (!suppressions[relativeFilePath]) {
+				continue;
+			}
+
+			const violationsByRule = SuppressionsService.countViolationsByRule(
+				result.messages,
+			);
+			let wasSuppressed = false;
+
+			for (const ruleId in violationsByRule) {
+				if (!suppressions[relativeFilePath][ruleId]) {
+					continue;
+				}
+
+				const suppressionsCount =
+					suppressions[relativeFilePath][ruleId].count;
+				const violationsCount = violationsByRule[ruleId].count;
+
+				// Suppress messages if the number of violations is less or equal to the suppressions count
+				if (violationsCount <= suppressionsCount) {
+					SuppressionsService.suppressMessagesByRule(result, ruleId);
+					wasSuppressed = true;
+				}
+
+				// Update the count to match the new number of violations, otherwise remove the rule entirely
+				if (violationsCount < suppressionsCount) {
+					unused[relativeFilePath] ??= {};
+					unused[relativeFilePath][ruleId] ??= {};
+					unused[relativeFilePath][ruleId].count =
+						suppressionsCount - violationsCount;
+				}
+			}
+
+			// Mark as unused all the suppressions that were not matched against a rule
+			for (const ruleId in suppressions[relativeFilePath]) {
+				if (violationsByRule[ruleId]) {
+					continue;
+				}
+
+				unused[relativeFilePath] ??= {};
+				unused[relativeFilePath][ruleId] =
+					suppressions[relativeFilePath][ruleId];
+			}
+
+			// Recalculate stats if messages were suppressed
+			if (wasSuppressed) {
+				Object.assign(result, calculateStatsPerFile(result.messages));
+			}
+		}
+
+		return {
+			results: filtered,
+			unused,
+		};
+	}
+
+	/**
+	 * Loads the suppressions file.
+	 * @throws {Error} If the suppressions file cannot be parsed.
+	 * @returns {Promise<SuppressedViolations>} The suppressions.
+	 */
+	async load() {
+		try {
+			const data = await fs.promises.readFile(this.filePath, "utf8");
+
+			return JSON.parse(data);
+		} catch (err) {
+			if (err.code === "ENOENT") {
+				return {};
+			}
+			throw new Error(
+				`Failed to parse suppressions file at ${this.filePath}`,
+				{
+					cause: err,
+				},
+			);
+		}
+	}
+
+	/**
+	 * Updates the suppressions file.
+	 * @param {SuppressedViolations} suppressions The suppressions to save.
+	 * @returns {Promise<void>}
+	 * @private
+	 */
+	save(suppressions) {
+		return fs.promises.writeFile(
+			this.filePath,
+			stringify(suppressions, { space: 2 }),
+		);
+	}
+
+	/**
+	 * Counts the violations by rule, ignoring warnings.
+	 * @param {LintMessage[]} messages The messages to count.
+	 * @returns {Record<string, number>} The number of violations by rule.
+	 */
+	static countViolationsByRule(messages) {
+		return messages.reduce((totals, message) => {
+			if (message.severity === 2 && message.ruleId) {
+				totals[message.ruleId] ??= { count: 0 };
+				totals[message.ruleId].count++;
+			}
+			return totals;
+		}, {});
+	}
+
+	/**
+	 * Returns the relative path of a file to the current working directory.
+	 * Always in POSIX format for consistency and interoperability.
+	 * @param {string} filePath The file path.
+	 * @returns {string} The relative file path.
+	 */
+	getRelativeFilePath(filePath) {
+		return path
+			.relative(this.cwd, filePath)
+			.split(path.sep)
+			.join(path.posix.sep);
+	}
+
+	/**
+	 * Moves the messages matching the rule to `LintResult#suppressedMessages` and updates the stats.
+	 * @param {LintResult} result The result to update.
+	 * @param {string} ruleId The rule to suppress.
+	 * @returns {void}
+	 */
+	static suppressMessagesByRule(result, ruleId) {
+		const suppressedMessages = result.messages.filter(
+			message => message.ruleId === ruleId,
+		);
+
+		result.suppressedMessages = result.suppressedMessages.concat(
+			suppressedMessages.map(message => {
+				message.suppressions = [
+					{
+						kind: "file",
+						justification: "",
+					},
+				];
+
+				return message;
+			}),
+		);
+
+		result.messages = result.messages.filter(
+			message => message.ruleId !== ruleId,
+		);
+	}
+}
+
+module.exports = { SuppressionsService };

package/lib/services/warning-service.js

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Emits warnings for ESLint.
+ * @author Francesco Trotta
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * A service that emits warnings for ESLint.
+ */
+class WarningService {
+	/**
+	 * Creates a new instance of the service.
+	 * @param {{ emitWarning?: ((warning: string, type: string) => void) | undefined }} [options] A function called internally to emit warnings using API provided by the runtime.
+	 */
+	constructor({
+		emitWarning = globalThis.process?.emitWarning ?? (() => {}),
+	} = {}) {
+		this.emitWarning = emitWarning;
+	}
+
+	/**
+	 * Emits a warning when circular fixes are detected while fixing a file.
+	 * This method is used by the Linter and is safe to call outside Node.js.
+	 * @param {string} filename The name of the file being fixed.
+	 * @returns {void}
+	 */
+	emitCircularFixesWarning(filename) {
+		this.emitWarning(
+			`Circular fixes detected while fixing ${filename}. It is likely that you have conflicting rules in your configuration.`,
+			"ESLintCircularFixesWarning",
+		);
+	}
+
+	/**
+	 * Emits a warning when an empty config file has been loaded.
+	 * @param {string} configFilePath The path to the config file.
+	 * @returns {void}
+	 */
+	emitEmptyConfigWarning(configFilePath) {
+		this.emitWarning(
+			`Running ESLint with an empty config (from ${configFilePath}). Please double-check that this is what you want. If you want to run ESLint with an empty config, export [{}] to remove this warning.`,
+			"ESLintEmptyConfigWarning",
+		);
+	}
+
+	/**
+	 * Emits a warning when an ".eslintignore" file is found.
+	 * @returns {void}
+	 */
+	emitESLintIgnoreWarning() {
+		this.emitWarning(
+			'The ".eslintignore" file is no longer supported. Switch to using the "ignores" property in "eslint.config.js": https://eslint.org/docs/latest/use/configure/migration-guide#ignoring-files',
+			"ESLintIgnoreWarning",
+		);
+	}
+
+	/**
+	 * Emits a warning when an inactive flag is used.
+	 * This method is used by the Linter and is safe to call outside Node.js.
+	 * @param {string} flag The name of the flag.
+	 * @param {string} message The warning message.
+	 * @returns {void}
+	 */
+	emitInactiveFlagWarning(flag, message) {
+		this.emitWarning(message, `ESLintInactiveFlag_${flag}`);
+	}
+
+	/**
+	 * Emits a warning when a suboptimal concurrency setting is detected.
+	 * Currently, this is only used to warn when the net linting ratio is low.
+	 * @param {string} notice A notice about how to improve performance.
+	 * @returns {void}
+	 */
+	emitPoorConcurrencyWarning(notice) {
+		this.emitWarning(
+			`You may ${notice} to improve performance.`,
+			"ESLintPoorConcurrencyWarning",
+		);
+	}
+}
+
+module.exports = { WarningService };

package/lib/shared/ajv.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview The instance of Ajv validator.
+ * @author Evgeny Poberezkin
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const Ajv = require("ajv"),
+	metaSchema = require("ajv/lib/refs/json-schema-draft-04.json");
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = (additionalOptions = {}) => {
+	const ajv = new Ajv({
+		meta: false,
+		useDefaults: true,
+		validateSchema: false,
+		missingRefs: "ignore",
+		verbose: true,
+		schemaId: "auto",
+		...additionalOptions,
+	});
+
+	ajv.addMetaSchema(metaSchema);
+	// eslint-disable-next-line no-underscore-dangle -- Ajv's API
+	ajv._opts.defaultMeta = metaSchema.id;
+
+	return ajv;
+};

package/lib/shared/assert.js

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Assertion utilities equivalent to the Node.js node:asserts module.
+ * @author Josh Goldberg
+ */
+
+"use strict";
+
+/**
+ * Throws an error if the input is not truthy.
+ * @param {unknown} value The input that is checked for being truthy.
+ * @param {string} message Message to throw if the input is not truthy.
+ * @returns {void}
+ * @throws {Error} When the condition is not truthy.
+ */
+function ok(value, message = "Assertion failed.") {
+	if (!value) {
+		throw new Error(message);
+	}
+}
+
+module.exports = ok;

package/lib/shared/ast-utils.js

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Common utils for AST.
+ *
+ * This file contains only shared items for core and rules.
+ * If you make a utility for rules, please see `../rules/utils/ast-utils.js`.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+const breakableTypePattern =
+	/^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;
+const lineBreakPattern = /\r\n|[\r\n\u2028\u2029]/u;
+const shebangPattern = /^#!([^\r\n]+)/u;
+
+/**
+ * Creates a version of the `lineBreakPattern` regex with the global flag.
+ * Global regexes are mutable, so this needs to be a function instead of a constant.
+ * @returns {RegExp} A global regular expression that matches line terminators
+ */
+function createGlobalLinebreakMatcher() {
+	return new RegExp(lineBreakPattern.source, "gu");
+}
+
+module.exports = {
+	breakableTypePattern,
+	lineBreakPattern,
+	createGlobalLinebreakMatcher,
+	shebangPattern,
+};

package/lib/shared/deep-merge-arrays.js

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Applies default rule options
+ * @author JoshuaKGoldberg
+ */
+
+"use strict";
+
+/**
+ * Check if the variable contains an object strictly rejecting arrays
+ * @param {unknown} value an object
+ * @returns {boolean} Whether value is an object
+ */
+function isObjectNotArray(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Deeply merges second on top of first, creating a new {} object if needed.
+ * @param {T} first Base, default value.
+ * @param {U} second User-specified value.
+ * @returns {T | U | (T & U)} Merged equivalent of second on top of first.
+ */
+function deepMergeObjects(first, second) {
+	if (second === void 0) {
+		return first;
+	}
+
+	if (!isObjectNotArray(first) || !isObjectNotArray(second)) {
+		return second;
+	}
+
+	const result = { ...first, ...second };
+
+	for (const key of Object.keys(second)) {
+		if (Object.prototype.propertyIsEnumerable.call(first, key)) {
+			result[key] = deepMergeObjects(first[key], second[key]);
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Deeply merges second on top of first, creating a new [] array if needed.
+ * @param {T[]} first Base, default values.
+ * @param {U[]} second User-specified values.
+ * @returns {(T | U | (T & U))[]} Merged equivalent of second on top of first.
+ */
+function deepMergeArrays(first, second) {
+	if (!first || !second) {
+		return second || first || [];
+	}
+
+	return [
+		...first.map((value, i) =>
+			deepMergeObjects(value, i < second.length ? second[i] : void 0),
+		),
+		...second.slice(first.length),
+	];
+}
+
+module.exports = { deepMergeArrays };

package/lib/shared/directives.js

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Common utils for directives.
+ *
+ * This file contains only shared items for directives.
+ * If you make a utility for rules, please see `../rules/utils/ast-utils.js`.
+ *
+ * @author gfyoung <https://github.com/gfyoung>
+ */
+"use strict";
+
+const directivesPattern =
+	/^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\s|$)/u;
+
+module.exports = {
+	directivesPattern,
+};

package/lib/shared/flags.js

@@ -0,0 +1,89 @@
+/**
+ * @fileoverview Shared flags for ESLint.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/**
+ * @typedef {Object} InactiveFlagData
+ * @property {string} description Flag description
+ * @property {string | null} [replacedBy] Can be either:
+ *   - An active flag (string) that enables the same feature.
+ *   - `null` if the feature is now enabled by default.
+ *   - Omitted if the feature has been abandoned.
+ */
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * The set of flags that change ESLint behavior with a description.
+ * @type {Map<string, string>}
+ */
+const activeFlags = new Map([
+	["test_only", "Used only for testing."],
+	["test_only_2", "Used only for testing."],
+	[
+		"unstable_native_nodejs_ts_config",
+		"Use native Node.js to load TypeScript configuration.",
+	],
+]);
+
+/**
+ * The set of flags that used to be active.
+ * @type {Map<string, InactiveFlagData>}
+ */
+const inactiveFlags = new Map([
+	[
+		"test_only_replaced",
+		{
+			description:
+				"Used only for testing flags that have been replaced by other flags.",
+			replacedBy: "test_only",
+		},
+	],
+	[
+		"test_only_enabled_by_default",
+		{
+			description:
+				"Used only for testing flags whose features have been enabled by default.",
+			replacedBy: null,
+		},
+	],
+	[
+		"test_only_abandoned",
+		{
+			description:
+				"Used only for testing flags whose features have been abandoned.",
+		},
+	],
+]);
+
+/**
+ * Creates a message that describes the reason the flag is inactive.
+ * @param {InactiveFlagData} inactiveFlagData Data for the inactive flag.
+ * @returns {string} Message describing the reason the flag is inactive.
+ */
+function getInactivityReasonMessage({ replacedBy }) {
+	if (typeof replacedBy === "undefined") {
+		return "This feature has been abandoned.";
+	}
+
+	if (typeof replacedBy === "string") {
+		return `This flag has been renamed '${replacedBy}' to reflect its stabilization. Please use '${replacedBy}' instead.`;
+	}
+
+	// null
+	return "This feature is now enabled by default.";
+}
+
+module.exports = {
+	activeFlags,
+	inactiveFlags,
+	getInactivityReasonMessage,
+};

package/lib/shared/logging.js

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Handle logging for ESLint
+ * @author Gyandeep Singh
+ */
+
+"use strict";
+
+/* eslint no-console: "off" -- Logging util */
+
+/* c8 ignore next */
+module.exports = {
+	/**
+	 * Cover for console.info
+	 * @param {...any} args The elements to log.
+	 * @returns {void}
+	 */
+	info(...args) {
+		console.log(...args);
+	},
+
+	/**
+	 * Cover for console.warn
+	 * @param {...any} args The elements to log.
+	 * @returns {void}
+	 */
+	warn(...args) {
+		console.warn(...args);
+	},
+
+	/**
+	 * Cover for console.error
+	 * @param {...any} args The elements to log.
+	 * @returns {void}
+	 */
+	error(...args) {
+		console.error(...args);
+	},
+};