bahlint 28.58.6934

package/lib/rules/id-length.js

@@ -0,0 +1,217 @@
+/**
+ * @fileoverview Rule that warns when identifier names are shorter or longer
+ * than the values provided in configuration.
+ * @author Burak Yigit Kaya aka BYK
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { getGraphemeCount } = require("../shared/string-utils");
+const {
+	getModuleExportName,
+	isImportAttributeKey,
+} = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				exceptionPatterns: [],
+				exceptions: [],
+				min: 2,
+				properties: "always",
+			},
+		],
+
+		docs: {
+			description: "Enforce minimum and maximum identifier lengths",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/id-length",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					min: {
+						type: "integer",
+					},
+					max: {
+						type: "integer",
+					},
+					exceptions: {
+						type: "array",
+						uniqueItems: true,
+						items: {
+							type: "string",
+						},
+					},
+					exceptionPatterns: {
+						type: "array",
+						uniqueItems: true,
+						items: {
+							type: "string",
+						},
+					},
+					properties: {
+						enum: ["always", "never"],
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		messages: {
+			tooShort: "Identifier name '{{name}}' is too short (< {{min}}).",
+			tooShortPrivate:
+				"Identifier name '#{{name}}' is too short (< {{min}}).",
+			tooLong: "Identifier name '{{name}}' is too long (> {{max}}).",
+			tooLongPrivate:
+				"Identifier name #'{{name}}' is too long (> {{max}}).",
+		},
+	},
+
+	create(context) {
+		const [options] = context.options;
+		const { max: maxLength = Infinity, min: minLength } = options;
+		const properties = options.properties !== "never";
+		const exceptions = new Set(options.exceptions);
+		const exceptionPatterns = options.exceptionPatterns.map(
+			pattern => new RegExp(pattern, "u"),
+		);
+		const reportedNodes = new Set();
+
+		/**
+		 * Checks if a string matches the provided exception patterns
+		 * @param {string} name The string to check.
+		 * @returns {boolean} if the string is a match
+		 * @private
+		 */
+		function matchesExceptionPattern(name) {
+			return exceptionPatterns.some(pattern => pattern.test(name));
+		}
+
+		const SUPPORTED_EXPRESSIONS = {
+			MemberExpression:
+				properties &&
+				function (parent) {
+					return (
+						!parent.computed &&
+						// regular property assignment
+						((parent.parent.left === parent &&
+							parent.parent.type === "AssignmentExpression") ||
+							// or the last identifier in an ObjectPattern destructuring
+							(parent.parent.type === "Property" &&
+								parent.parent.value === parent &&
+								parent.parent.parent.type === "ObjectPattern" &&
+								parent.parent.parent.parent.left ===
+									parent.parent.parent))
+					);
+				},
+			AssignmentPattern(parent, node) {
+				return parent.left === node;
+			},
+			VariableDeclarator(parent, node) {
+				return parent.id === node;
+			},
+			Property(parent, node) {
+				if (parent.parent.type === "ObjectPattern") {
+					const isKeyAndValueSame =
+						parent.value.name === parent.key.name;
+
+					return (
+						(!isKeyAndValueSame && parent.value === node) ||
+						(isKeyAndValueSame && parent.key === node && properties)
+					);
+				}
+				return (
+					properties &&
+					!isImportAttributeKey(node) &&
+					!parent.computed &&
+					parent.key.name === node.name
+				);
+			},
+			ImportSpecifier(parent, node) {
+				return (
+					parent.local === node &&
+					getModuleExportName(parent.imported) !==
+						getModuleExportName(parent.local)
+				);
+			},
+			ImportDefaultSpecifier: true,
+			ImportNamespaceSpecifier: true,
+			RestElement: true,
+			FunctionExpression: true,
+			ArrowFunctionExpression: true,
+			ClassDeclaration: true,
+			FunctionDeclaration: true,
+			MethodDefinition: true,
+			PropertyDefinition: true,
+			CatchClause: true,
+			ArrayPattern: true,
+		};
+
+		return {
+			[["Identifier", "PrivateIdentifier"]](node) {
+				const name = node.name;
+				const parent = node.parent;
+
+				const nameLength = getGraphemeCount(name);
+
+				const isShort = nameLength < minLength;
+				const isLong = nameLength > maxLength;
+
+				if (
+					!(isShort || isLong) ||
+					exceptions.has(name) ||
+					matchesExceptionPattern(name)
+				) {
+					return; // Nothing to report
+				}
+
+				const isValidExpression = SUPPORTED_EXPRESSIONS[parent.type];
+
+				/*
+				 * We used the range instead of the node because it's possible
+				 * for the same identifier to be represented by two different
+				 * nodes, with the most clear example being shorthand properties:
+				 * { foo }
+				 * In this case, "foo" is represented by one node for the name
+				 * and one for the value. The only way to know they are the same
+				 * is to look at the range.
+				 */
+				if (
+					isValidExpression &&
+					!reportedNodes.has(node.range.toString()) &&
+					(isValidExpression === true ||
+						isValidExpression(parent, node))
+				) {
+					reportedNodes.add(node.range.toString());
+
+					let messageId = isShort ? "tooShort" : "tooLong";
+
+					if (node.type === "PrivateIdentifier") {
+						messageId += "Private";
+					}
+
+					context.report({
+						node,
+						messageId,
+						data: { name, min: minLength, max: maxLength },
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/id-match.js

@@ -0,0 +1,363 @@
+/**
+ * @fileoverview Rule to flag non-matching identifiers
+ * @author Matthieu Larcher
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			"^.+$",
+			{
+				classFields: false,
+				ignoreDestructuring: false,
+				onlyDeclarations: false,
+				properties: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Require identifiers to match a specified regular expression",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/id-match",
+		},
+
+		schema: [
+			{
+				type: "string",
+			},
+			{
+				type: "object",
+				properties: {
+					properties: {
+						type: "boolean",
+					},
+					classFields: {
+						type: "boolean",
+					},
+					onlyDeclarations: {
+						type: "boolean",
+					},
+					ignoreDestructuring: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		messages: {
+			notMatch:
+				"Identifier '{{name}}' does not match the pattern '{{pattern}}'.",
+			notMatchPrivate:
+				"Identifier '#{{name}}' does not match the pattern '{{pattern}}'.",
+		},
+	},
+
+	create(context) {
+		//--------------------------------------------------------------------------
+		// Options
+		//--------------------------------------------------------------------------
+		const [
+			pattern,
+			{
+				classFields: checkClassFields,
+				ignoreDestructuring,
+				onlyDeclarations,
+				properties: checkProperties,
+			},
+		] = context.options;
+		const regexp = new RegExp(pattern, "u");
+
+		const sourceCode = context.sourceCode;
+		let globalScope;
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		// contains reported nodes to avoid reporting twice on destructuring with shorthand notation
+		const reportedNodes = new Set();
+		const ALLOWED_PARENT_TYPES = new Set([
+			"CallExpression",
+			"NewExpression",
+		]);
+		const DECLARATION_TYPES = new Set([
+			"FunctionDeclaration",
+			"VariableDeclarator",
+		]);
+		const IMPORT_TYPES = new Set([
+			"ImportSpecifier",
+			"ImportNamespaceSpecifier",
+			"ImportDefaultSpecifier",
+		]);
+
+		/**
+		 * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+		 * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
+		 * @param {ASTNode} node `Identifier` node to check.
+		 * @returns {boolean} `true` if the node is a reference to a global variable.
+		 */
+		function isReferenceToGlobalVariable(node) {
+			const variable = globalScope.set.get(node.name);
+
+			return (
+				variable &&
+				variable.defs.length === 0 &&
+				variable.references.some(ref => ref.identifier === node)
+			);
+		}
+
+		/**
+		 * Checks if a string matches the provided pattern
+		 * @param {string} name The string to check.
+		 * @returns {boolean} if the string is a match
+		 * @private
+		 */
+		function isInvalid(name) {
+			return !regexp.test(name);
+		}
+
+		/**
+		 * Checks if a parent of a node is an ObjectPattern.
+		 * @param {ASTNode} node The node to check.
+		 * @returns {boolean} if the node is inside an ObjectPattern
+		 * @private
+		 */
+		function isInsideObjectPattern(node) {
+			let { parent } = node;
+
+			while (parent) {
+				if (parent.type === "ObjectPattern") {
+					return true;
+				}
+
+				parent = parent.parent;
+			}
+
+			return false;
+		}
+
+		/**
+		 * Verifies if we should report an error or not based on the effective
+		 * parent node and the identifier name.
+		 * @param {ASTNode} effectiveParent The effective parent node of the node to be reported
+		 * @param {string} name The identifier name of the identifier node
+		 * @returns {boolean} whether an error should be reported or not
+		 */
+		function shouldReport(effectiveParent, name) {
+			return (
+				(!onlyDeclarations ||
+					DECLARATION_TYPES.has(effectiveParent.type)) &&
+				!ALLOWED_PARENT_TYPES.has(effectiveParent.type) &&
+				isInvalid(name)
+			);
+		}
+
+		/**
+		 * Reports an AST node as a rule violation.
+		 * @param {ASTNode} node The node to report.
+		 * @returns {void}
+		 * @private
+		 */
+		function report(node) {
+			/*
+			 * We used the range instead of the node because it's possible
+			 * for the same identifier to be represented by two different
+			 * nodes, with the most clear example being shorthand properties:
+			 * { foo }
+			 * In this case, "foo" is represented by one node for the name
+			 * and one for the value. The only way to know they are the same
+			 * is to look at the range.
+			 */
+			if (!reportedNodes.has(node.range.toString())) {
+				const messageId =
+					node.type === "PrivateIdentifier"
+						? "notMatchPrivate"
+						: "notMatch";
+
+				context.report({
+					node,
+					messageId,
+					data: {
+						name: node.name,
+						pattern,
+					},
+				});
+				reportedNodes.add(node.range.toString());
+			}
+		}
+
+		return {
+			Program(node) {
+				globalScope = sourceCode.getScope(node);
+			},
+
+			Identifier(node) {
+				const name = node.name,
+					parent = node.parent,
+					effectiveParent =
+						parent.type === "MemberExpression"
+							? parent.parent
+							: parent;
+
+				if (
+					isReferenceToGlobalVariable(node) ||
+					astUtils.isImportAttributeKey(node)
+				) {
+					return;
+				}
+
+				if (parent.type === "MemberExpression") {
+					if (!checkProperties) {
+						return;
+					}
+
+					// Always check object names
+					if (
+						parent.object.type === "Identifier" &&
+						parent.object.name === name
+					) {
+						if (isInvalid(name)) {
+							report(node);
+						}
+
+						// Report AssignmentExpressions left side's assigned variable id
+					} else if (
+						effectiveParent.type === "AssignmentExpression" &&
+						effectiveParent.left.type === "MemberExpression" &&
+						effectiveParent.left.property.name === node.name
+					) {
+						if (isInvalid(name)) {
+							report(node);
+						}
+
+						// Report AssignmentExpressions only if they are the left side of the assignment
+					} else if (
+						effectiveParent.type === "AssignmentExpression" &&
+						effectiveParent.right.type !== "MemberExpression"
+					) {
+						if (isInvalid(name)) {
+							report(node);
+						}
+					}
+
+					// For https://github.com/eslint/eslint/issues/15123
+				} else if (
+					parent.type === "Property" &&
+					parent.parent.type === "ObjectExpression" &&
+					parent.key === node &&
+					!parent.computed
+				) {
+					if (checkProperties && isInvalid(name)) {
+						report(node);
+					}
+
+					/*
+					 * Properties have their own rules, and
+					 * AssignmentPattern nodes can be treated like Properties:
+					 * e.g.: const { no_camelcased = false } = bar;
+					 */
+				} else if (
+					parent.type === "Property" ||
+					parent.type === "AssignmentPattern"
+				) {
+					if (
+						parent.parent &&
+						parent.parent.type === "ObjectPattern"
+					) {
+						if (
+							!ignoreDestructuring &&
+							parent.shorthand &&
+							parent.value.left &&
+							isInvalid(name)
+						) {
+							report(node);
+						}
+
+						const assignmentKeyEqualsValue =
+							parent.key.name === parent.value.name;
+
+						// prevent checking righthand side of destructured object
+						if (!assignmentKeyEqualsValue && parent.key === node) {
+							return;
+						}
+
+						const valueIsInvalid =
+							parent.value.name && isInvalid(name);
+
+						// ignore destructuring if the option is set, unless a new identifier is created
+						if (
+							valueIsInvalid &&
+							!(assignmentKeyEqualsValue && ignoreDestructuring)
+						) {
+							report(node);
+						}
+					}
+
+					// never check properties or always ignore destructuring
+					if (
+						(!checkProperties && !parent.computed) ||
+						(ignoreDestructuring && isInsideObjectPattern(node))
+					) {
+						return;
+					}
+
+					// don't check right hand side of AssignmentExpression to prevent duplicate warnings
+					if (
+						parent.right !== node &&
+						shouldReport(effectiveParent, name)
+					) {
+						report(node);
+					}
+
+					// Check if it's an import specifier
+				} else if (IMPORT_TYPES.has(parent.type)) {
+					// Report only if the local imported identifier is invalid
+					if (
+						parent.local &&
+						parent.local.name === node.name &&
+						isInvalid(name)
+					) {
+						report(node);
+					}
+				} else if (parent.type === "PropertyDefinition") {
+					if (checkClassFields && isInvalid(name)) {
+						report(node);
+					}
+
+					// Report anything that is invalid that isn't a CallExpression
+				} else if (shouldReport(effectiveParent, name)) {
+					report(node);
+				}
+			},
+
+			PrivateIdentifier(node) {
+				const isClassField = node.parent.type === "PropertyDefinition";
+
+				if (isClassField && !checkClassFields) {
+					return;
+				}
+
+				if (isInvalid(node.name)) {
+					report(node);
+				}
+			},
+		};
+	},
+};

package/lib/rules/implicit-arrow-linebreak.js

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview enforce the location of arrow function bodies
+ * @author Sharmila Jesupaul
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+const { isCommentToken, isNotOpeningParenToken } = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		deprecated: {
+			message: "Formatting rules are being moved out of ESLint core.",
+			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+			deprecatedSince: "8.53.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "implicit-arrow-linebreak",
+						url: "https://eslint.style/rules/implicit-arrow-linebreak",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Enforce the location of arrow function bodies",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/implicit-arrow-linebreak",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				enum: ["beside", "below"],
+			},
+		],
+		messages: {
+			expected: "Expected a linebreak before this expression.",
+			unexpected: "Expected no linebreak before this expression.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const option = context.options[0] || "beside";
+
+		/**
+		 * Validates the location of an arrow function body
+		 * @param {ASTNode} node The arrow function body
+		 * @returns {void}
+		 */
+		function validateExpression(node) {
+			if (node.body.type === "BlockStatement") {
+				return;
+			}
+
+			const arrowToken = sourceCode.getTokenBefore(
+				node.body,
+				isNotOpeningParenToken,
+			);
+			const firstTokenOfBody = sourceCode.getTokenAfter(arrowToken);
+
+			if (
+				arrowToken.loc.end.line === firstTokenOfBody.loc.start.line &&
+				option === "below"
+			) {
+				context.report({
+					node: firstTokenOfBody,
+					messageId: "expected",
+					fix: fixer =>
+						fixer.insertTextBefore(firstTokenOfBody, "\n"),
+				});
+			} else if (
+				arrowToken.loc.end.line !== firstTokenOfBody.loc.start.line &&
+				option === "beside"
+			) {
+				context.report({
+					node: firstTokenOfBody,
+					messageId: "unexpected",
+					fix(fixer) {
+						if (
+							sourceCode.getFirstTokenBetween(
+								arrowToken,
+								firstTokenOfBody,
+								{
+									includeComments: true,
+									filter: isCommentToken,
+								},
+							)
+						) {
+							return null;
+						}
+
+						return fixer.replaceTextRange(
+							[arrowToken.range[1], firstTokenOfBody.range[0]],
+							" ",
+						);
+					},
+				});
+			}
+		}
+
+		//----------------------------------------------------------------------
+		// Public
+		//----------------------------------------------------------------------
+		return {
+			ArrowFunctionExpression: node => validateExpression(node),
+		};
+	},
+};