eslint 9.28.0 → 9.29.0

package/lib/linter/source-code-visitor.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview SourceCodeVisitor class
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+const emptyArray = Object.freeze([]);
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+/**
+ * A structure to hold a list of functions to call for a given name.
+ * This is used to allow multiple rules to register functions for a given name
+ * without having to know about each other.
+ */
+class SourceCodeVisitor {
+	/**
+	 * The functions to call for a given name.
+	 * @type {Map<string, Function[]>}
+	 */
+	#functions = new Map();
+
+	/**
+	 * Adds a function to the list of functions to call for a given name.
+	 * @param {string} name The name of the function to call.
+	 * @param {Function} func The function to call.
+	 * @returns {void}
+	 */
+	add(name, func) {
+		if (this.#functions.has(name)) {
+			this.#functions.get(name).push(func);
+		} else {
+			this.#functions.set(name, [func]);
+		}
+	}
+
+	/**
+	 * Gets the list of functions to call for a given name.
+	 * @param {string} name The name of the function to call.
+	 * @returns {Function[]} The list of functions to call.
+	 */
+	get(name) {
+		if (this.#functions.has(name)) {
+			return this.#functions.get(name);
+		}
+
+		return emptyArray;
+	}
+
+	/**
+	 * Iterates over all names and calls the callback with the name.
+	 * @param {(name:string) => void} callback The callback to call for each name.
+	 * @returns {void}
+	 */
+	forEachName(callback) {
+		this.#functions.forEach((funcs, name) => {
+			callback(name);
+		});
+	}
+
+	/**
+	 * Calls the functions for a given name with the given arguments.
+	 * @param {string} name The name of the function to call.
+	 * @param {any[]} args The arguments to pass to the function.
+	 * @returns {void}
+	 */
+	callSync(name, ...args) {
+		if (this.#functions.has(name)) {
+			this.#functions.get(name).forEach(func => func(...args));
+		}
+	}
+}
+
+module.exports = { SourceCodeVisitor };

package/lib/rules/class-methods-use-this.js

@@ -111,6 +111,7 @@ module.exports = {
 			switch (node.type) {
 				case "MethodDefinition":
 					return !node.static && node.kind !== "constructor";
+				case "AccessorProperty":
 				case "PropertyDefinition":
 					return !node.static && enforceForClassFields;
 				default:
@@ -218,6 +219,8 @@ module.exports = {
 			/*
 			 * Class field value are implicit functions.
 			 */
+			"AccessorProperty > *.key:exit": pushContext,
+			"AccessorProperty:exit": popContext,
 			"PropertyDefinition > *.key:exit": pushContext,
 			"PropertyDefinition:exit": popContext,
 
@@ -233,6 +236,10 @@ module.exports = {
 			ThisExpression: markThisUsed,
 			Super: markThisUsed,
 			...(enforceForClassFields && {
+				"AccessorProperty > ArrowFunctionExpression.value":
+					enterFunction,
+				"AccessorProperty > ArrowFunctionExpression.value:exit":
+					exitFunction,
 				"PropertyDefinition > ArrowFunctionExpression.value":
 					enterFunction,
 				"PropertyDefinition > ArrowFunctionExpression.value:exit":

package/lib/rules/no-promise-executor-return.js

@@ -9,7 +9,6 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { findVariable } = require("@eslint-community/eslint-utils");
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -21,43 +20,13 @@ const functionTypesToCheck = new Set([
 	"FunctionExpression",
 ]);
 
-/**
- * Determines whether the given identifier node is a reference to a global variable.
- * @param {ASTNode} node `Identifier` node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @returns {boolean} True if the identifier is a reference to a global variable.
- */
-function isGlobalReference(node, scope) {
-	const variable = findVariable(scope, node);
-
-	return (
-		variable !== null &&
-		variable.scope.type === "global" &&
-		variable.defs.length === 0
-	);
-}
-
-/**
- * Finds function's outer scope.
- * @param {Scope} scope Function's own scope.
- * @returns {Scope} Function's outer scope.
- */
-function getOuterScope(scope) {
-	const upper = scope.upper;
-
-	if (upper.type === "function-expression-name") {
-		return upper.upper;
-	}
-	return upper;
-}
-
 /**
  * Determines whether the given function node is used as a Promise executor.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Function's own scope.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @returns {boolean} `true` if the node is a Promise executor.
  */
-function isPromiseExecutor(node, scope) {
+function isPromiseExecutor(node, sourceCode) {
 	const parent = node.parent;
 
 	return (
@@ -65,7 +34,7 @@ function isPromiseExecutor(node, scope) {
 		parent.arguments[0] === node &&
 		parent.callee.type === "Identifier" &&
 		parent.callee.name === "Promise" &&
-		isGlobalReference(parent.callee, getOuterScope(scope))
+		sourceCode.isGlobalReference(parent.callee)
 	);
 }
 
@@ -203,7 +172,7 @@ module.exports = {
 					upper: funcInfo,
 					shouldCheck:
 						functionTypesToCheck.has(node.type) &&
-						isPromiseExecutor(node, sourceCode.getScope(node)),
+						isPromiseExecutor(node, sourceCode),
 				};
 
 				if (

package/lib/rules/no-restricted-globals.js

@@ -4,6 +4,18 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const TYPE_NODES = new Set([
+	"TSTypeReference",
+	"TSInterfaceHeritage",
+	"TSClassImplements",
+	"TSTypeQuery",
+	"TSQualifiedName",
+]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -11,6 +23,8 @@
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "suggestion",
 
 		docs: {
@@ -100,6 +114,18 @@ module.exports = {
 			return Object.hasOwn(restrictedGlobalMessages, name);
 		}
 
+		/**
+		 * Check if the given reference occurs within a TypeScript type context.
+		 * @param {Reference} reference The variable reference to check.
+		 * @returns {boolean} Whether the reference is in a type context.
+		 * @private
+		 */
+		function isInTypeContext(reference) {
+			const parent = reference.identifier.parent;
+
+			return TYPE_NODES.has(parent.type);
+		}
+
 		return {
 			Program(node) {
 				const scope = sourceCode.getScope(node);
@@ -107,13 +133,20 @@ module.exports = {
 				// Report variables declared elsewhere (ex: variables defined as "global" by eslint)
 				scope.variables.forEach(variable => {
 					if (!variable.defs.length && isRestricted(variable.name)) {
-						variable.references.forEach(reportReference);
+						variable.references.forEach(reference => {
+							if (!isInTypeContext(reference)) {
+								reportReference(reference);
+							}
+						});
 					}
 				});
 
 				// Report variables not declared at all
 				scope.through.forEach(reference => {
-					if (isRestricted(reference.identifier.name)) {
+					if (
+						isRestricted(reference.identifier.name) &&
+						!isInTypeContext(reference)
+					) {
 						reportReference(reference);
 					}
 				});

package/lib/rules/no-restricted-properties.js

@@ -40,6 +40,13 @@ module.exports = {
 						},
 						uniqueItems: true,
 					},
+					allowProperties: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+						uniqueItems: true,
+					},
 					message: {
 						type: "string",
 					},
@@ -53,7 +60,10 @@ module.exports = {
 					},
 				],
 				not: {
-					required: ["allowObjects", "object"],
+					anyOf: [
+						{ required: ["allowObjects", "object"] },
+						{ required: ["allowProperties", "property"] },
+					],
 				},
 				additionalProperties: false,
 			},
@@ -92,6 +102,7 @@ module.exports = {
 				});
 			} else if (typeof propertyName === "undefined") {
 				globallyRestrictedObjects.set(objectName, {
+					allowProperties: option.allowProperties,
 					message: option.message,
 				});
 			} else {
@@ -106,17 +117,17 @@ module.exports = {
 		});
 
 		/**
-		 * Checks if an object name is in the allowed objects list.
-		 * @param {string} objectName The name of the object to check
-		 * @param {string[]} [allowObjects] The list of objects to allow
-		 * @returns {boolean} True if the object is allowed, false otherwise
+		 * Checks if a name is in the allowed list.
+		 * @param {string} name The name to check
+		 * @param {string[]} [allowedList] The list of allowed names
+		 * @returns {boolean} True if the name is allowed, false otherwise
 		 */
-		function isAllowedObject(objectName, allowObjects) {
-			if (!allowObjects) {
+		function isAllowed(name, allowedList) {
+			if (!allowedList) {
 				return false;
 			}
 
-			return allowObjects.includes(objectName);
+			return allowedList.includes(name);
 		}
 
 		/**
@@ -137,7 +148,10 @@ module.exports = {
 			const globalMatchedProperty =
 				globallyRestrictedProperties.get(propertyName);
 
-			if (matchedObjectProperty) {
+			if (
+				matchedObjectProperty &&
+				!isAllowed(propertyName, matchedObjectProperty.allowProperties)
+			) {
 				const message = matchedObjectProperty.message
 					? ` ${matchedObjectProperty.message}`
 					: "";
@@ -153,7 +167,7 @@ module.exports = {
 				});
 			} else if (
 				globalMatchedProperty &&
-				!isAllowedObject(objectName, globalMatchedProperty.allowObjects)
+				!isAllowed(objectName, globalMatchedProperty.allowObjects)
 			) {
 				const message = globalMatchedProperty.message
 					? ` ${globalMatchedProperty.message}`

package/lib/rules/no-setter-return.js

@@ -10,33 +10,16 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const { findVariable } = require("@eslint-community/eslint-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-/**
- * Determines whether the given identifier node is a reference to a global variable.
- * @param {ASTNode} node `Identifier` node to check.
- * @param {Scope} scope Scope to which the node belongs.
- * @returns {boolean} True if the identifier is a reference to a global variable.
- */
-function isGlobalReference(node, scope) {
-	const variable = findVariable(scope, node);
-
-	return (
-		variable !== null &&
-		variable.scope.type === "global" &&
-		variable.defs.length === 0
-	);
-}
-
 /**
  * Determines whether the given node is an argument of the specified global method call, at the given `index` position.
  * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @param {string} objectName Name of the global object.
  * @param {string} methodName Name of the method.
  * @param {number} index The given position.
@@ -44,7 +27,7 @@ function isGlobalReference(node, scope) {
  */
 function isArgumentOfGlobalMethodCall(
 	node,
-	scope,
+	sourceCode,
 	objectName,
 	methodName,
 	index,
@@ -59,9 +42,8 @@ function isArgumentOfGlobalMethodCall(
 			objectName,
 			methodName,
 		) &&
-		isGlobalReference(
+		sourceCode.isGlobalReference(
 			astUtils.skipChainExpression(callNode.callee).object,
-			scope,
 		)
 	);
 }
@@ -69,21 +51,21 @@ function isArgumentOfGlobalMethodCall(
 /**
  * Determines whether the given node is used as a property descriptor.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @returns {boolean} `true` if the node is a property descriptor.
  */
-function isPropertyDescriptor(node, scope) {
+function isPropertyDescriptor(node, sourceCode) {
 	if (
 		isArgumentOfGlobalMethodCall(
 			node,
-			scope,
+			sourceCode,
 			"Object",
 			"defineProperty",
 			2,
 		) ||
 		isArgumentOfGlobalMethodCall(
 			node,
-			scope,
+			sourceCode,
 			"Reflect",
 			"defineProperty",
 			2,
@@ -101,14 +83,14 @@ function isPropertyDescriptor(node, scope) {
 			grandparent.type === "ObjectExpression" &&
 			(isArgumentOfGlobalMethodCall(
 				grandparent,
-				scope,
+				sourceCode,
 				"Object",
 				"create",
 				1,
 			) ||
 				isArgumentOfGlobalMethodCall(
 					grandparent,
-					scope,
+					sourceCode,
 					"Object",
 					"defineProperties",
 					1,
@@ -124,10 +106,10 @@ function isPropertyDescriptor(node, scope) {
 /**
  * Determines whether the given function node is used as a setter function.
  * @param {ASTNode} node The node to check.
- * @param {Scope} scope Scope to which the node belongs.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
  * @returns {boolean} `true` if the node is a setter.
  */
-function isSetter(node, scope) {
+function isSetter(node, sourceCode) {
 	const parent = node.parent;
 
 	if (
@@ -144,7 +126,7 @@ function isSetter(node, scope) {
 		parent.value === node &&
 		astUtils.getStaticPropertyName(parent) === "set" &&
 		parent.parent.type === "ObjectExpression" &&
-		isPropertyDescriptor(parent.parent, scope)
+		isPropertyDescriptor(parent.parent, sourceCode)
 	) {
 		// Setter in a property descriptor
 		return true;
@@ -153,21 +135,6 @@ function isSetter(node, scope) {
 	return false;
 }
 
-/**
- * Finds function's outer scope.
- * @param {Scope} scope Function's own scope.
- * @returns {Scope} Function's outer scope.
- */
-function getOuterScope(scope) {
-	const upper = scope.upper;
-
-	if (upper.type === "function-expression-name") {
-		return upper.upper;
-	}
-
-	return upper;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -200,11 +167,9 @@ module.exports = {
 		 * @returns {void}
 		 */
 		function enterFunction(node) {
-			const outerScope = getOuterScope(sourceCode.getScope(node));
-
 			funcInfo = {
 				upper: funcInfo,
-				isSetter: isSetter(node, outerScope),
+				isSetter: isSetter(node, sourceCode),
 			};
 		}
 

package/lib/rules/no-use-before-define.js

@@ -269,6 +269,8 @@ function isClassRefInClassDecorator(variable, reference) {
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "problem",
 
 		docs: {

package/lib/rules/no-var.js

@@ -199,6 +199,8 @@ function hasNameDisallowedForLetDeclarations(variable) {
 module.exports = {
 	meta: {
 		type: "suggestion",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
 
 		docs: {
 			description: "Require `let` or `const` instead of `var`",
@@ -346,9 +348,19 @@ module.exports = {
 
 		return {
 			"VariableDeclaration:exit"(node) {
-				if (node.kind === "var") {
-					report(node);
+				if (node.kind !== "var") {
+					return;
 				}
+
+				if (
+					node.parent.type === "TSModuleBlock" &&
+					node.parent.parent.type === "TSModuleDeclaration" &&
+					node.parent.parent.global
+				) {
+					return;
+				}
+
+				report(node);
 			},
 		};
 	},

package/lib/rules/prefer-regex-literals.js

@@ -14,7 +14,6 @@ const {
 	CALL,
 	CONSTRUCT,
 	ReferenceTracker,
-	findVariable,
 } = require("@eslint-community/eslint-utils");
 const {
 	RegExpValidator,
@@ -167,22 +166,6 @@ module.exports = {
 		const [{ disallowRedundantWrapping }] = context.options;
 		const sourceCode = context.sourceCode;
 
-		/**
-		 * Determines whether the given identifier node is a reference to a global variable.
-		 * @param {ASTNode} node `Identifier` node to check.
-		 * @returns {boolean} True if the identifier is a reference to a global variable.
-		 */
-		function isGlobalReference(node) {
-			const scope = sourceCode.getScope(node);
-			const variable = findVariable(scope, node);
-
-			return (
-				variable !== null &&
-				variable.scope.type === "global" &&
-				variable.defs.length === 0
-			);
-		}
-
 		/**
 		 * Determines whether the given node is a String.raw`` tagged template expression
 		 * with a static template literal.
@@ -193,7 +176,7 @@ module.exports = {
 			return (
 				node.type === "TaggedTemplateExpression" &&
 				astUtils.isSpecificMemberAccess(node.tag, "String", "raw") &&
-				isGlobalReference(
+				sourceCode.isGlobalReference(
 					astUtils.skipChainExpression(node.tag).object,
 				) &&
 				astUtils.isStaticTemplateLiteral(node.quasi)

package/lib/services/suppressions-service.js

@@ -112,6 +112,14 @@ class SuppressionsService {
 			}
 		}
 
+		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);
 	}
 

package/lib/shared/naming.js

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview Common helpers for naming of plugins, formatters and configs
+ */
+
+"use strict";
+
+const NAMESPACE_REGEX = /^@.*\//iu;
+
+/**
+ * Brings package name to correct format based on prefix
+ * @param {string} name The name of the package.
+ * @param {string} prefix Can be either "eslint-plugin", "eslint-config" or "eslint-formatter"
+ * @returns {string} Normalized name of the package
+ * @private
+ */
+function normalizePackageName(name, prefix) {
+	let normalizedName = name;
+
+	/**
+	 * On Windows, name can come in with Windows slashes instead of Unix slashes.
+	 * Normalize to Unix first to avoid errors later on.
+	 * https://github.com/eslint/eslint/issues/5644
+	 */
+	if (normalizedName.includes("\\")) {
+		normalizedName = normalizedName.replace(/\\/gu, "/");
+	}
+
+	if (normalizedName.charAt(0) === "@") {
+		/**
+		 * it's a scoped package
+		 * package name is the prefix, or just a username
+		 */
+		const scopedPackageShortcutRegex = new RegExp(
+				`^(@[^/]+)(?:/(?:${prefix})?)?$`,
+				"u",
+			),
+			scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, "u");
+
+		if (scopedPackageShortcutRegex.test(normalizedName)) {
+			normalizedName = normalizedName.replace(
+				scopedPackageShortcutRegex,
+				`$1/${prefix}`,
+			);
+		} else if (!scopedPackageNameRegex.test(normalizedName.split("/")[1])) {
+			/**
+			 * for scoped packages, insert the prefix after the first / unless
+			 * the path is already @scope/eslint or @scope/eslint-xxx-yyy
+			 */
+			normalizedName = normalizedName.replace(
+				/^@([^/]+)\/(.*)$/u,
+				`@$1/${prefix}-$2`,
+			);
+		}
+	} else if (!normalizedName.startsWith(`${prefix}-`)) {
+		normalizedName = `${prefix}-${normalizedName}`;
+	}
+
+	return normalizedName;
+}
+
+/**
+ * Removes the prefix from a fullname.
+ * @param {string} fullname The term which may have the prefix.
+ * @param {string} prefix The prefix to remove.
+ * @returns {string} The term without prefix.
+ */
+function getShorthandName(fullname, prefix) {
+	if (fullname[0] === "@") {
+		let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec(
+			fullname,
+		);
+
+		if (matchResult) {
+			return matchResult[1];
+		}
+
+		matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec(
+			fullname,
+		);
+		if (matchResult) {
+			return `${matchResult[1]}/${matchResult[2]}`;
+		}
+	} else if (fullname.startsWith(`${prefix}-`)) {
+		return fullname.slice(prefix.length + 1);
+	}
+
+	return fullname;
+}
+
+/**
+ * Gets the scope (namespace) of a term.
+ * @param {string} term The term which may have the namespace.
+ * @returns {string} The namespace of the term if it has one.
+ */
+function getNamespaceFromTerm(term) {
+	const match = term.match(NAMESPACE_REGEX);
+
+	return match ? match[0] : "";
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+	normalizePackageName,
+	getShorthandName,
+	getNamespaceFromTerm,
+};