eslint 9.25.1 → 9.27.0

package/lib/config/config.js

@@ -10,16 +10,31 @@
 //-----------------------------------------------------------------------------
 
 const { deepMergeArrays } = require("../shared/deep-merge-arrays");
-const { getRuleFromConfig } = require("./flat-config-helpers");
 const { flatConfigSchema, hasMethod } = require("./flat-config-schema");
-const { RuleValidator } = require("./rule-validator");
 const { ObjectSchema } = require("@eslint/config-array");
+const ajvImport = require("../shared/ajv");
+const ajv = ajvImport();
+const ruleReplacements = require("../../conf/replacements.json");
 
 //-----------------------------------------------------------------------------
-// Helpers
+// Typedefs
+//-----------------------------------------------------------------------------
+
+/**
+ * @import { RuleDefinition } from "@eslint/core";
+ * @import { Linter } from "eslint";
+ */
+
 //-----------------------------------------------------------------------------
+// Private Members
+//------------------------------------------------------------------------------
 
-const ruleValidator = new RuleValidator();
+// JSON schema that disallows passing any options
+const noOptionsSchema = Object.freeze({
+	type: "array",
+	minItems: 0,
+	maxItems: 0,
+});
 
 const severities = new Map([
 	[0, 0],
@@ -30,6 +45,174 @@ const severities = new Map([
 	["error", 2],
 ]);
 
+/**
+ * A collection of compiled validators for rules that have already
+ * been validated.
+ * @type {WeakMap}
+ */
+const validators = new WeakMap();
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+/**
+ * Throws a helpful error when a rule cannot be found.
+ * @param {Object} ruleId The rule identifier.
+ * @param {string} ruleId.pluginName The ID of the rule to find.
+ * @param {string} ruleId.ruleName The ID of the rule to find.
+ * @param {Object} config The config to search in.
+ * @throws {TypeError} For missing plugin or rule.
+ * @returns {void}
+ */
+function throwRuleNotFoundError({ pluginName, ruleName }, config) {
+	const ruleId = pluginName === "@" ? ruleName : `${pluginName}/${ruleName}`;
+
+	const errorMessageHeader = `Key "rules": Key "${ruleId}"`;
+
+	let errorMessage = `${errorMessageHeader}: Could not find plugin "${pluginName}" in configuration.`;
+
+	const missingPluginErrorMessage = errorMessage;
+
+	// if the plugin exists then we need to check if the rule exists
+	if (config.plugins && config.plugins[pluginName]) {
+		const replacementRuleName = ruleReplacements.rules[ruleName];
+
+		if (pluginName === "@" && replacementRuleName) {
+			errorMessage = `${errorMessageHeader}: Rule "${ruleName}" was removed and replaced by "${replacementRuleName}".`;
+		} else {
+			errorMessage = `${errorMessageHeader}: Could not find "${ruleName}" in plugin "${pluginName}".`;
+
+			// otherwise, let's see if we can find the rule name elsewhere
+			for (const [otherPluginName, otherPlugin] of Object.entries(
+				config.plugins,
+			)) {
+				if (otherPlugin.rules && otherPlugin.rules[ruleName]) {
+					errorMessage += ` Did you mean "${otherPluginName}/${ruleName}"?`;
+					break;
+				}
+			}
+		}
+
+		// falls through to throw error
+	}
+
+	const error = new TypeError(errorMessage);
+
+	if (errorMessage === missingPluginErrorMessage) {
+		error.messageTemplate = "config-plugin-missing";
+		error.messageData = { pluginName, ruleId };
+	}
+
+	throw error;
+}
+
+/**
+ * The error type when a rule has an invalid `meta.schema`.
+ */
+class InvalidRuleOptionsSchemaError extends Error {
+	/**
+	 * Creates a new instance.
+	 * @param {string} ruleId Id of the rule that has an invalid `meta.schema`.
+	 * @param {Error} processingError Error caught while processing the `meta.schema`.
+	 */
+	constructor(ruleId, processingError) {
+		super(
+			`Error while processing options validation schema of rule '${ruleId}': ${processingError.message}`,
+			{ cause: processingError },
+		);
+		this.code = "ESLINT_INVALID_RULE_OPTIONS_SCHEMA";
+	}
+}
+
+/**
+ * Parses a ruleId into its plugin and rule parts.
+ * @param {string} ruleId The rule ID to parse.
+ * @returns {{pluginName:string,ruleName:string}} The plugin and rule
+ *      parts of the ruleId;
+ */
+function parseRuleId(ruleId) {
+	let pluginName, ruleName;
+
+	// distinguish between core rules and plugin rules
+	if (ruleId.includes("/")) {
+		// mimic scoped npm packages
+		if (ruleId.startsWith("@")) {
+			pluginName = ruleId.slice(0, ruleId.lastIndexOf("/"));
+		} else {
+			pluginName = ruleId.slice(0, ruleId.indexOf("/"));
+		}
+
+		ruleName = ruleId.slice(pluginName.length + 1);
+	} else {
+		pluginName = "@";
+		ruleName = ruleId;
+	}
+
+	return {
+		pluginName,
+		ruleName,
+	};
+}
+
+/**
+ * Retrieves a rule instance from a given config based on the ruleId.
+ * @param {string} ruleId The rule ID to look for.
+ * @param {Linter.Config} config The config to search.
+ * @returns {RuleDefinition|undefined} The rule if found
+ *      or undefined if not.
+ */
+function getRuleFromConfig(ruleId, config) {
+	const { pluginName, ruleName } = parseRuleId(ruleId);
+
+	return config.plugins?.[pluginName]?.rules?.[ruleName];
+}
+
+/**
+ * Gets a complete options schema for a rule.
+ * @param {RuleDefinition} rule A rule object
+ * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`.
+ * @returns {Object|null} JSON Schema for the rule's options. `null` if `meta.schema` is `false`.
+ */
+function getRuleOptionsSchema(rule) {
+	if (!rule.meta) {
+		return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+	}
+
+	const schema = rule.meta.schema;
+
+	if (typeof schema === "undefined") {
+		return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+	}
+
+	// `schema:false` is an allowed explicit opt-out of options validation for the rule
+	if (schema === false) {
+		return null;
+	}
+
+	if (typeof schema !== "object" || schema === null) {
+		throw new TypeError("Rule's `meta.schema` must be an array or object");
+	}
+
+	// ESLint-specific array form needs to be converted into a valid JSON Schema definition
+	if (Array.isArray(schema)) {
+		if (schema.length) {
+			return {
+				type: "array",
+				items: schema,
+				minItems: 0,
+				maxItems: schema.length,
+			};
+		}
+
+		// `schema:[]` is an explicit way to specify that the rule does not accept any options
+		return { ...noOptionsSchema };
+	}
+
+	// `schema:<object>` is assumed to be a valid JSON Schema definition
+	return schema;
+}
+
 /**
  * Splits a plugin identifier in the form a/b/c into two parts: a/b and c.
  * @param {string} identifier The identifier to parse.
@@ -124,6 +307,29 @@ function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
 	return result;
 }
 
+/**
+ * Gets or creates a validator for a rule.
+ * @param {Object} rule The rule to get a validator for.
+ * @param {string} ruleId The ID of the rule (for error reporting).
+ * @returns {Function|null} A validation function or null if no validation is needed.
+ * @throws {InvalidRuleOptionsSchemaError} If a rule's `meta.schema` is invalid.
+ */
+function getOrCreateValidator(rule, ruleId) {
+	if (!validators.has(rule)) {
+		try {
+			const schema = getRuleOptionsSchema(rule);
+
+			if (schema) {
+				validators.set(rule, ajv.compile(schema));
+			}
+		} catch (err) {
+			throw new InvalidRuleOptionsSchemaError(ruleId, err);
+		}
+	}
+
+	return validators.get(rule);
+}
+
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
@@ -252,7 +458,7 @@ class Config {
 		// Process the rules
 		if (this.rules) {
 			this.#normalizeRulesConfig();
-			ruleValidator.validate(this);
+			this.validateRulesConfig(this.rules);
 		}
 	}
 
@@ -291,6 +497,15 @@ class Config {
 		};
 	}
 
+	/**
+	 * Gets a rule configuration by its ID.
+	 * @param {string} ruleId The ID of the rule to get.
+	 * @returns {RuleDefinition|undefined} The rule definition from the plugin, or `undefined` if the rule is not found.
+	 */
+	getRuleDefinition(ruleId) {
+		return getRuleFromConfig(ruleId, this);
+	}
+
 	/**
 	 * Normalizes the rules configuration. Ensures that each rule config is
 	 * an array and that the severity is a number. Applies meta.defaultOptions.
@@ -323,6 +538,114 @@ class Config {
 			this.rules[ruleId] = ruleConfig;
 		}
 	}
+
+	/**
+	 * Validates all of the rule configurations in the given rules config
+	 * against the plugins in this instance. This is used primarily to
+	 * validate inline configuration rules while inting.
+	 * @param {Object} rulesConfig The rules config to validate.
+	 * @returns {void}
+	 * @throws {Error} If a rule's configuration does not match its schema.
+	 * @throws {TypeError} If the rulesConfig is not provided or is invalid.
+	 * @throws {InvalidRuleOptionsSchemaError} If a rule's `meta.schema` is invalid.
+	 * @throws {TypeError} If a rule is not found in the plugins.
+	 */
+	validateRulesConfig(rulesConfig) {
+		if (!rulesConfig) {
+			throw new TypeError("Config is required for validation.");
+		}
+
+		for (const [ruleId, ruleOptions] of Object.entries(rulesConfig)) {
+			// check for edge case
+			if (ruleId === "__proto__") {
+				continue;
+			}
+
+			/*
+			 * If a rule is disabled, we don't do any validation. This allows
+			 * users to safely set any value to 0 or "off" without worrying
+			 * that it will cause a validation error.
+			 *
+			 * Note: ruleOptions is always an array at this point because
+			 * this validation occurs after FlatConfigArray has merged and
+			 * normalized values.
+			 */
+			if (ruleOptions[0] === 0) {
+				continue;
+			}
+
+			const rule = getRuleFromConfig(ruleId, this);
+
+			if (!rule) {
+				throwRuleNotFoundError(parseRuleId(ruleId), this);
+			}
+
+			const validateRule = getOrCreateValidator(rule, ruleId);
+
+			if (validateRule) {
+				validateRule(ruleOptions.slice(1));
+
+				if (validateRule.errors) {
+					throw new Error(
+						`Key "rules": Key "${ruleId}":\n${validateRule.errors
+							.map(error => {
+								if (
+									error.keyword === "additionalProperties" &&
+									error.schema === false &&
+									typeof error.parentSchema?.properties ===
+										"object" &&
+									typeof error.params?.additionalProperty ===
+										"string"
+								) {
+									const expectedProperties = Object.keys(
+										error.parentSchema.properties,
+									).map(property => `"${property}"`);
+
+									return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n\t\tUnexpected property "${error.params.additionalProperty}". Expected properties: ${expectedProperties.join(", ")}.\n`;
+								}
+
+								return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`;
+							})
+							.join("")}`,
+					);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Gets a complete options schema for a rule.
+	 * @param {RuleDefinition} ruleDefinition A rule definition object.
+	 * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`.
+	 * @returns {Object|null} JSON Schema for the rule's options. `null` if `meta.schema` is `false`.
+	 */
+	static getRuleOptionsSchema(ruleDefinition) {
+		return getRuleOptionsSchema(ruleDefinition);
+	}
+
+	/**
+	 * Normalizes the severity value of a rule's configuration to a number
+	 * @param {(number|string|[number, ...*]|[string, ...*])} ruleConfig A rule's configuration value, generally
+	 * received from the user. A valid config value is either 0, 1, 2, the string "off" (treated the same as 0),
+	 * the string "warn" (treated the same as 1), the string "error" (treated the same as 2), or an array
+	 * whose first element is one of the above values. Strings are matched case-insensitively.
+	 * @returns {(0|1|2)} The numeric severity value if the config value was valid, otherwise 0.
+	 */
+	static getRuleNumericSeverity(ruleConfig) {
+		const severityValue = Array.isArray(ruleConfig)
+			? ruleConfig[0]
+			: ruleConfig;
+
+		if (severities.has(severityValue)) {
+			return severities.get(severityValue);
+		}
+
+		if (typeof severityValue === "string") {
+			return severities.get(severityValue.toLowerCase()) ?? 0;
+		}
+
+		return 0;
+	}
 }
 
 module.exports = { Config };

package/lib/eslint/eslint-helpers.js

@@ -30,10 +30,12 @@ const MINIMATCH_OPTIONS = { dot: true };
 
 /**
  * @import { ESLintOptions } from "./eslint.js";
- * @import { LintMessage, LintResult } from "../shared/types.js";
  * @import { ConfigLoader, LegacyConfigLoader } from "../config/config-loader.js";
  */
 
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
+
 /**
  * @typedef {Object} GlobSearch
  * @property {Array<string>} patterns The normalized patterns to use for a search.

package/lib/eslint/eslint.js

@@ -14,7 +14,6 @@ const { existsSync } = require("node:fs");
 const path = require("node:path");
 const { version } = require("../../package.json");
 const { Linter } = require("../linter");
-const { getRuleFromConfig } = require("../config/flat-config-helpers");
 const { defaultConfig } = require("../config/default-config");
 const {
 	Legacy: {
@@ -57,16 +56,21 @@ const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
  * @import { CLIEngineLintReport } from "./legacy-eslint.js";
  * @import { FlatConfigArray } from "../config/flat-config-array.js";
  * @import { RuleDefinition } from "@eslint/core";
- * @import { ConfigData, DeprecatedRuleInfo, LintMessage, LintResult, Plugin, ResultsMeta } from "../shared/types.js";
  */
 
 /** @typedef {ReturnType<ConfigArray.extractConfig>} ExtractedConfig */
+/** @typedef {import("../types").Linter.Config} Config */
+/** @typedef {import("../types").ESLint.DeprecatedRuleUse} DeprecatedRuleInfo */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
+/** @typedef {import("../types").ESLint.Plugin} Plugin */
+/** @typedef {import("../types").ESLint.ResultsMeta} ResultsMeta */
 
 /**
  * The options with which to configure the ESLint instance.
  * @typedef {Object} ESLintOptions
  * @property {boolean} [allowInlineConfig] Enable or disable inline configuration comments.
- * @property {ConfigData|Array<ConfigData>} [baseConfig] Base config, extended by all configs used with this instance
+ * @property {Config|Array<Config>} [baseConfig] Base config, extended by all configs used with this instance
  * @property {boolean} [cache] Enable result caching.
  * @property {string} [cacheLocation] The cache file to use instead of .eslintcache.
  * @property {"metadata" | "content"} [cacheStrategy] The strategy used to detect changed files.
@@ -78,7 +82,7 @@ const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
  * @property {boolean} [globInputPaths] Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
  * @property {boolean} [ignore] False disables all ignore patterns except for the default ones.
  * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to config ignores. These patterns are relative to `cwd`.
- * @property {ConfigData|Array<ConfigData>} [overrideConfig] Override config, overrides all configs used with this instance
+ * @property {Config|Array<Config>} [overrideConfig] Override config, overrides all configs used with this instance
  * @property {boolean|string} [overrideConfigFile] Searches for default config file when falsy;
  *      doesn't do any config file lookup when `true`; considered to be a config filename
  *      when a string.
@@ -158,7 +162,7 @@ function getOrFindUsedDeprecatedRules(eslint, maybeFilePath) {
 				if (getRuleSeverity(ruleConf) === 0) {
 					continue;
 				}
-				const rule = getRuleFromConfig(ruleId, config);
+				const rule = config.getRuleDefinition(ruleId);
 				const meta = rule && rule.meta;
 
 				if (meta && meta.deprecated) {
@@ -352,7 +356,7 @@ function shouldMessageBeFixed(message, config, fixTypes) {
 		return fixTypes.has("directive");
 	}
 
-	const rule = message.ruleId && getRuleFromConfig(message.ruleId, config);
+	const rule = message.ruleId && config.getRuleDefinition(message.ruleId);
 
 	return Boolean(rule && rule.meta && fixTypes.has(rule.meta.type));
 }
@@ -386,6 +390,20 @@ function getFixerForFixTypes(fix, fixTypesSet, config) {
 		originalFix(message);
 }
 
+/**
+ * Retrieves flags from the environment variable ESLINT_FLAGS.
+ * @param {string[]} flags The flags defined via the API.
+ * @returns {string[]} The merged flags to use.
+ */
+function mergeEnvironmentFlags(flags) {
+	if (!process.env.ESLINT_FLAGS) {
+		return flags;
+	}
+
+	const envFlags = process.env.ESLINT_FLAGS.trim().split(/\s*,\s*/gu);
+	return Array.from(new Set([...envFlags, ...flags]));
+}
+
 //-----------------------------------------------------------------------------
 // Main API
 //-----------------------------------------------------------------------------
@@ -416,7 +434,7 @@ class ESLint {
 		const linter = new Linter({
 			cwd: processedOptions.cwd,
 			configType: "flat",
-			flags: processedOptions.flags,
+			flags: mergeEnvironmentFlags(processedOptions.flags),
 		});
 
 		const cacheFilePath = getCacheFile(
@@ -610,7 +628,7 @@ class ESLint {
 				if (!config) {
 					throw createExtraneousResultsError();
 				}
-				const rule = getRuleFromConfig(ruleId, config);
+				const rule = config.getRuleDefinition(ruleId);
 
 				// ignore unknown rules
 				if (rule) {
@@ -703,15 +721,11 @@ class ESLint {
 			debug(`Deleting cache file at ${cacheFilePath}`);
 
 			try {
-				await fs.unlink(cacheFilePath);
+				if (existsSync(cacheFilePath)) {
+					await fs.unlink(cacheFilePath);
+				}
 			} catch (error) {
-				const errorCode = error && error.code;
-
-				// Ignore errors when no such file exists or file system is read only (and cache file does not exist)
-				if (
-					errorCode !== "ENOENT" &&
-					!(errorCode === "EROFS" && !existsSync(cacheFilePath))
-				) {
+				if (existsSync(cacheFilePath)) {
 					throw error;
 				}
 			}
@@ -1071,7 +1085,7 @@ class ESLint {
 	 * This is the same logic used by the ESLint CLI executable to determine
 	 * configuration for each file it processes.
 	 * @param {string} filePath The path of the file to retrieve a config object for.
-	 * @returns {Promise<ConfigData|undefined>} A configuration object for the file
+	 * @returns {Promise<Config|undefined>} A configuration object for the file
 	 *      or `undefined` if there is no configuration data for the object.
 	 */
 	async calculateConfigForFile(filePath) {

package/lib/eslint/legacy-eslint.js

@@ -30,14 +30,14 @@ const { version } = require("../../package.json");
 //------------------------------------------------------------------------------
 
 /** @typedef {import("../cli-engine/cli-engine").LintReport} CLIEngineLintReport */
-/** @typedef {import("../shared/types").DeprecatedRuleInfo} DeprecatedRuleInfo */
-/** @typedef {import("../shared/types").ConfigData} ConfigData */
-/** @typedef {import("../shared/types").LintMessage} LintMessage */
-/** @typedef {import("../shared/types").SuppressedLintMessage} SuppressedLintMessage */
-/** @typedef {import("../shared/types").Plugin} Plugin */
+/** @typedef {import("../types").ESLint.ConfigData} ConfigData */
+/** @typedef {import("../types").ESLint.DeprecatedRuleUse} DeprecatedRuleInfo */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
+/** @typedef {import("../types").ESLint.Plugin} Plugin */
+/** @typedef {import("../types").ESLint.ResultsMeta} ResultsMeta */
 /** @typedef {import("../types").Rule.RuleModule} Rule */
-/** @typedef {import("../shared/types").LintResult} LintResult */
-/** @typedef {import("../shared/types").ResultsMeta} ResultsMeta */
+/** @typedef {import("../types").Linter.SuppressedLintMessage} SuppressedLintMessage */
 
 /**
  * The main formatter object.

package/lib/languages/js/index.js

@@ -25,6 +25,7 @@ const { LATEST_ECMA_VERSION } = require("../../../conf/ecma-version");
 /** @typedef {import("@eslint/core").File} File */
 /** @typedef {import("@eslint/core").Language} Language */
 /** @typedef {import("@eslint/core").OkParseResult} OkParseResult */
+/** @typedef {import("../../types").Linter.LanguageOptions} JSLanguageOptions */
 
 //-----------------------------------------------------------------------------
 // Helpers
@@ -37,7 +38,7 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 /**
  * Analyze scope of the given AST.
  * @param {ASTNode} ast The `Program` node to analyze.
- * @param {LanguageOptions} languageOptions The parser options.
+ * @param {JSLanguageOptions} languageOptions The parser options.
  * @param {Record<string, string[]>} visitorKeys The visitor keys.
  * @returns {ScopeManager} The analysis result.
  */
@@ -230,7 +231,7 @@ module.exports = {
 	 * Parses the given file into an AST.
 	 * @param {File} file The virtual file to parse.
 	 * @param {Object} options Additional options passed from ESLint.
-	 * @param {LanguageOptions} options.languageOptions The language options.
+	 * @param {JSLanguageOptions} options.languageOptions The language options.
 	 * @returns {Object} The result of parsing.
 	 */
 	parse(file, { languageOptions }) {
@@ -309,7 +310,7 @@ module.exports = {
 	 * @param {File} file The virtual file to create a `SourceCode` object from.
 	 * @param {OkParseResult} parseResult The result returned from `parse()`.
 	 * @param {Object} options Additional options passed from ESLint.
-	 * @param {LanguageOptions} options.languageOptions The language options.
+	 * @param {JSLanguageOptions} options.languageOptions The language options.
 	 * @returns {SourceCode} The new `SourceCode` object.
 	 */
 	createSourceCode(file, parseResult, { languageOptions }) {

package/lib/languages/js/source-code/source-code.js

@@ -53,7 +53,7 @@ const CODE_PATH_EVENTS = [
 /**
  * Validates that the given AST has the required information.
  * @param {ASTNode} ast The Program node of the AST to check.
- * @throws {Error} If the AST doesn't contain the correct information.
+ * @throws {TypeError} If the AST doesn't contain the correct information.
  * @returns {void}
  * @private
  */
@@ -147,8 +147,8 @@ function sortedMerge(tokens, comments) {
  * Normalizes a value for a global in a config
  * @param {(boolean|string|null)} configuredValue The value given for a global in configuration or in
  * a global directive comment
- * @returns {("readable"|"writeable"|"off")} The value normalized as a string
- * @throws Error if global value is invalid
+ * @returns {("readonly"|"writable"|"off")} The value normalized as a string
+ * @throws {Error} if global value is invalid
  */
 function normalizeConfigGlobal(configuredValue) {
 	switch (configuredValue) {
@@ -471,6 +471,10 @@ class SourceCode extends TokenStore {
 		 * @type {string[]}
 		 */
 		this.lines = [];
+
+		/**
+		 * @type {number[]}
+		 */
 		this.lineStartIndices = [0];
 
 		const lineEndingPattern = astUtils.createGlobalLinebreakMatcher();
@@ -528,7 +532,7 @@ class SourceCode extends TokenStore {
 
 	/**
 	 * Gets the entire source text split into an array of lines.
-	 * @returns {Array} The source text as an array of lines.
+	 * @returns {string[]} The source text as an array of lines.
 	 * @public
 	 */
 	getLines() {
@@ -687,8 +691,8 @@ class SourceCode extends TokenStore {
 	/**
 	 * Converts a source text index into a (line, column) pair.
 	 * @param {number} index The index of a character in a file
-	 * @throws {TypeError} If non-numeric index or index out of range.
-	 * @returns {Object} A {line, column} location object with a 0-indexed column
+	 * @throws {TypeError|RangeError} If non-numeric index or index out of range.
+	 * @returns {{line: number, column: number}} A {line, column} location object with a 0-indexed column
 	 * @public
 	 */
 	getLocFromIndex(index) {

package/lib/linter/apply-disable-directives.js

@@ -9,7 +9,7 @@
 // Typedefs
 //------------------------------------------------------------------------------
 
-/** @typedef {import("../shared/types").LintMessage} LintMessage */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
 /** @typedef {import("@eslint/core").Language} Language */
 /** @typedef {import("@eslint/core").Position} Position */
 /** @typedef {import("@eslint/core").RulesConfig} RulesConfig */