bahlint 28.58.6934-dev-001

package/lib/rules/no-empty-function.js

@@ -0,0 +1,236 @@
+/**
+ * @fileoverview Rule to disallow empty functions.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const ALLOW_OPTIONS = Object.freeze([
+	"functions",
+	"arrowFunctions",
+	"generatorFunctions",
+	"methods",
+	"generatorMethods",
+	"getters",
+	"setters",
+	"constructors",
+	"asyncFunctions",
+	"asyncMethods",
+	"privateConstructors",
+	"protectedConstructors",
+	"decoratedFunctions",
+	"overrideMethods",
+]);
+
+/**
+ * Gets the kind of a given function node.
+ * @param {ASTNode} node A function node to get. This is one of
+ *      an ArrowFunctionExpression, a FunctionDeclaration, or a
+ *      FunctionExpression.
+ * @returns {string} The kind of the function. This is one of "functions",
+ *      "arrowFunctions", "generatorFunctions", "asyncFunctions", "methods",
+ *      "generatorMethods", "asyncMethods", "getters", "setters", and
+ *      "constructors".
+ */
+function getKind(node) {
+	const parent = node.parent;
+	let kind;
+
+	if (node.type === "ArrowFunctionExpression") {
+		return "arrowFunctions";
+	}
+
+	// Detects main kind.
+	if (parent.type === "Property") {
+		if (parent.kind === "get") {
+			return "getters";
+		}
+		if (parent.kind === "set") {
+			return "setters";
+		}
+		kind = parent.method ? "methods" : "functions";
+	} else if (parent.type === "MethodDefinition") {
+		if (parent.kind === "get") {
+			return "getters";
+		}
+		if (parent.kind === "set") {
+			return "setters";
+		}
+		if (parent.kind === "constructor") {
+			return "constructors";
+		}
+		kind = "methods";
+	} else {
+		kind = "functions";
+	}
+
+	// Detects prefix.
+	let prefix;
+
+	if (node.generator) {
+		prefix = "generator";
+	} else if (node.async) {
+		prefix = "async";
+	} else {
+		return kind;
+	}
+	return prefix + kind[0].toUpperCase() + kind.slice(1);
+}
+
+/**
+ * Checks if a constructor function has parameter properties.
+ * @param {ASTNode} node The function node to examine.
+ * @returns {boolean} True if the constructor has parameter properties, false otherwise.
+ */
+function isParameterPropertiesConstructor(node) {
+	return node.params.some(param => param.type === "TSParameterProperty");
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
+		hasSuggestions: true,
+		type: "suggestion",
+
+		defaultOptions: [{ allow: [] }],
+
+		docs: {
+			description: "Disallow empty functions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-empty-function",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allow: {
+						type: "array",
+						items: { enum: ALLOW_OPTIONS },
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpected: "Unexpected empty {{name}}.",
+			suggestComment: "Add comment inside empty {{name}}.",
+		},
+	},
+
+	create(context) {
+		const [{ allow }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Checks if the given function node is allowed to be empty.
+		 * @param {ASTNode} node The function node to check.
+		 * @returns {boolean} True if the function is allowed to be empty, false otherwise.
+		 */
+		function isAllowedEmptyFunction(node) {
+			const kind = getKind(node);
+
+			if (allow.includes(kind)) {
+				return true;
+			}
+
+			if (kind === "constructors") {
+				if (
+					(node.parent.accessibility === "private" &&
+						allow.includes("privateConstructors")) ||
+					(node.parent.accessibility === "protected" &&
+						allow.includes("protectedConstructors")) ||
+					isParameterPropertiesConstructor(node)
+				) {
+					return true;
+				}
+			}
+
+			if (/(?:g|s)etters|methods$/iu.test(kind)) {
+				if (
+					(node.parent.decorators?.length &&
+						allow.includes("decoratedFunctions")) ||
+					(node.parent.override && allow.includes("overrideMethods"))
+				) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		/**
+		 * Reports a given function node if the node matches the following patterns.
+		 *
+		 * - Not allowed by options.
+		 * - The body is empty.
+		 * - The body doesn't have any comments.
+		 * @param {ASTNode} node A function node to report. This is one of
+		 *      an ArrowFunctionExpression, a FunctionDeclaration, or a
+		 *      FunctionExpression.
+		 * @returns {void}
+		 */
+		function reportIfEmpty(node) {
+			const name = astUtils.getFunctionNameWithKind(node);
+			const innerComments = sourceCode.getTokens(node.body, {
+				includeComments: true,
+				filter: astUtils.isCommentToken,
+			});
+
+			if (
+				!isAllowedEmptyFunction(node) &&
+				node.body.type === "BlockStatement" &&
+				node.body.body.length === 0 &&
+				innerComments.length === 0
+			) {
+				context.report({
+					node,
+					loc: node.body.loc,
+					messageId: "unexpected",
+					data: { name },
+					suggest: [
+						{
+							messageId: "suggestComment",
+							data: { name },
+							fix(fixer) {
+								const range = [
+									node.body.range[0] + 1,
+									node.body.range[1] - 1,
+								];
+
+								return fixer.replaceTextRange(
+									range,
+									" /* empty */ ",
+								);
+							},
+						},
+					],
+				});
+			}
+		}
+
+		return {
+			ArrowFunctionExpression: reportIfEmpty,
+			FunctionDeclaration: reportIfEmpty,
+			FunctionExpression: reportIfEmpty,
+		};
+	},
+};

package/lib/rules/no-empty-pattern.js

@@ -0,0 +1,85 @@
+/**
+ * @fileoverview Rule to disallow an empty pattern
+ * @author Alberto Rodríguez
+ */
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		defaultOptions: [
+			{
+				allowObjectPatternsAsParameters: false,
+			},
+		],
+
+		docs: {
+			description: "Disallow empty destructuring patterns",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-empty-pattern",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowObjectPatternsAsParameters: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpected: "Unexpected empty {{type}} pattern.",
+		},
+	},
+
+	create(context) {
+		const [{ allowObjectPatternsAsParameters }] = context.options;
+
+		return {
+			ObjectPattern(node) {
+				if (node.properties.length > 0) {
+					return;
+				}
+
+				// Allow {} and {} = {} empty object patterns as parameters when allowObjectPatternsAsParameters is true
+				if (
+					allowObjectPatternsAsParameters &&
+					(astUtils.isFunction(node.parent) ||
+						(node.parent.type === "AssignmentPattern" &&
+							astUtils.isFunction(node.parent.parent) &&
+							node.parent.right.type === "ObjectExpression" &&
+							node.parent.right.properties.length === 0))
+				) {
+					return;
+				}
+
+				context.report({
+					node,
+					messageId: "unexpected",
+					data: { type: "object" },
+				});
+			},
+			ArrayPattern(node) {
+				if (node.elements.length === 0) {
+					context.report({
+						node,
+						messageId: "unexpected",
+						data: { type: "array" },
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-empty-static-block.js

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Rule to disallow empty static blocks.
+ * @author Sosuke Suzuki
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow empty static blocks",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-empty-static-block",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpected: "Unexpected empty static block.",
+			suggestComment: "Add comment inside empty static block.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			StaticBlock(node) {
+				if (node.body.length === 0) {
+					const openingBrace = sourceCode.getFirstToken(node, {
+						skip: 1,
+					});
+					const closingBrace = sourceCode.getLastToken(node);
+
+					if (
+						sourceCode.getCommentsBefore(closingBrace).length === 0
+					) {
+						context.report({
+							loc: {
+								start: openingBrace.loc.start,
+								end: closingBrace.loc.end,
+							},
+							messageId: "unexpected",
+							suggest: [
+								{
+									messageId: "suggestComment",
+									fix(fixer) {
+										const range = [
+											openingBrace.range[1],
+											closingBrace.range[0],
+										];
+
+										return fixer.replaceTextRange(
+											range,
+											" /* empty */ ",
+										);
+									},
+								},
+							],
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-empty.js

@@ -0,0 +1,153 @@
+/**
+ * @fileoverview Rule to flag use of an empty block statement
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				allowEmptyCatch: false,
+			},
+		],
+
+		docs: {
+			description: "Disallow empty block statements",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-empty",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowEmptyCatch: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpected: "Empty {{type}} statement.",
+			suggestComment: "Add comment inside empty {{type}} statement.",
+		},
+	},
+
+	create(context) {
+		const [{ allowEmptyCatch }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		return {
+			BlockStatement(node) {
+				// if the body is not empty, we can just return immediately
+				if (node.body.length !== 0) {
+					return;
+				}
+
+				// a function is generally allowed to be empty
+				if (astUtils.isFunction(node.parent)) {
+					return;
+				}
+
+				if (allowEmptyCatch && node.parent.type === "CatchClause") {
+					return;
+				}
+
+				// any other block is only allowed to be empty, if it contains a comment
+				if (sourceCode.getCommentsInside(node).length > 0) {
+					return;
+				}
+
+				context.report({
+					node,
+					messageId: "unexpected",
+					data: { type: "block" },
+					suggest: [
+						{
+							messageId: "suggestComment",
+							data: { type: "block" },
+							fix(fixer) {
+								const range = [
+									node.range[0] + 1,
+									node.range[1] - 1,
+								];
+
+								return fixer.replaceTextRange(
+									range,
+									" /* empty */ ",
+								);
+							},
+						},
+					],
+				});
+			},
+
+			SwitchStatement(node) {
+				if (
+					typeof node.cases === "undefined" ||
+					node.cases.length === 0
+				) {
+					const openingBrace = sourceCode.getTokenAfter(
+						node.discriminant,
+						astUtils.isOpeningBraceToken,
+					);
+
+					const closingBrace = sourceCode.getLastToken(node);
+
+					if (
+						sourceCode.commentsExistBetween(
+							openingBrace,
+							closingBrace,
+						)
+					) {
+						return;
+					}
+
+					context.report({
+						node,
+						loc: {
+							start: openingBrace.loc.start,
+							end: closingBrace.loc.end,
+						},
+						messageId: "unexpected",
+						data: { type: "switch" },
+						suggest: [
+							{
+								messageId: "suggestComment",
+								data: { type: "switch" },
+								fix(fixer) {
+									const range = [
+										openingBrace.range[1],
+										closingBrace.range[0],
+									];
+
+									return fixer.replaceTextRange(
+										range,
+										" /* empty */ ",
+									);
+								},
+							},
+						],
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-eq-null.js

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Rule to flag comparisons to null without a type-checking
+ * operator.
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow `null` comparisons without type-checking operators",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-eq-null",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpected: "Use '===' to compare with null.",
+		},
+	},
+
+	create(context) {
+		return {
+			BinaryExpression(node) {
+				const badOperator =
+					node.operator === "==" || node.operator === "!=";
+
+				if (
+					(node.right.type === "Literal" &&
+						node.right.raw === "null" &&
+						badOperator) ||
+					(node.left.type === "Literal" &&
+						node.left.raw === "null" &&
+						badOperator)
+				) {
+					context.report({ node, messageId: "unexpected" });
+				}
+			},
+		};
+	},
+};