bahlint 28.58.6934-dev-001

package/lib/rules/no-negated-condition.js

@@ -0,0 +1,100 @@
+/**
+ * @fileoverview Rule to disallow a negated condition
+ * @author Alberto Rodríguez
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow negated conditions",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-negated-condition",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpectedNegated: "Unexpected negated condition.",
+		},
+	},
+
+	create(context) {
+		/**
+		 * Determines if a given node is an if-else without a condition on the else
+		 * @param {ASTNode} node The node to check.
+		 * @returns {boolean} True if the node has an else without an if.
+		 * @private
+		 */
+		function hasElseWithoutCondition(node) {
+			return node.alternate && node.alternate.type !== "IfStatement";
+		}
+
+		/**
+		 * Determines if a given node is a negated unary expression
+		 * @param {Object} test The test object to check.
+		 * @returns {boolean} True if the node is a negated unary expression.
+		 * @private
+		 */
+		function isNegatedUnaryExpression(test) {
+			return test.type === "UnaryExpression" && test.operator === "!";
+		}
+
+		/**
+		 * Determines if a given node is a negated binary expression
+		 * @param {Test} test The test to check.
+		 * @returns {boolean} True if the node is a negated binary expression.
+		 * @private
+		 */
+		function isNegatedBinaryExpression(test) {
+			return (
+				test.type === "BinaryExpression" &&
+				(test.operator === "!=" || test.operator === "!==")
+			);
+		}
+
+		/**
+		 * Determines if a given node has a negated if expression
+		 * @param {ASTNode} node The node to check.
+		 * @returns {boolean} True if the node has a negated if expression.
+		 * @private
+		 */
+		function isNegatedIf(node) {
+			return (
+				isNegatedUnaryExpression(node.test) ||
+				isNegatedBinaryExpression(node.test)
+			);
+		}
+
+		return {
+			IfStatement(node) {
+				if (!hasElseWithoutCondition(node)) {
+					return;
+				}
+
+				if (isNegatedIf(node)) {
+					context.report({
+						node,
+						messageId: "unexpectedNegated",
+					});
+				}
+			},
+			ConditionalExpression(node) {
+				if (isNegatedIf(node)) {
+					context.report({
+						node,
+						messageId: "unexpectedNegated",
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-negated-in-lhs.js

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview A rule to disallow negated left operands of the `in` operator
+ * @author Michael Ficarra
+ * @deprecated in ESLint v3.3.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow negating the left operand in `in` expressions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-negated-in-lhs",
+		},
+
+		deprecated: {
+			message: "Renamed rule.",
+			url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules",
+			deprecatedSince: "3.3.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					rule: {
+						name: "no-unsafe-negation",
+						url: "https://eslint.org/docs/rules/no-unsafe-negation",
+					},
+				},
+			],
+		},
+		schema: [],
+
+		messages: {
+			negatedLHS: "The 'in' expression's left operand is negated.",
+		},
+	},
+
+	create(context) {
+		return {
+			BinaryExpression(node) {
+				if (
+					node.operator === "in" &&
+					node.left.type === "UnaryExpression" &&
+					node.left.operator === "!"
+				) {
+					context.report({ node, messageId: "negatedLHS" });
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-nested-ternary.js

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Rule to flag nested ternary expressions
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow nested ternary expressions",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-nested-ternary",
+		},
+
+		schema: [],
+
+		messages: {
+			noNestedTernary: "Do not nest ternary expressions.",
+		},
+	},
+
+	create(context) {
+		return {
+			ConditionalExpression(node) {
+				if (
+					node.alternate.type === "ConditionalExpression" ||
+					node.consequent.type === "ConditionalExpression"
+				) {
+					context.report({
+						node,
+						messageId: "noNestedTernary",
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-new-func.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview Rule to flag when using new Function
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const callMethods = new Set(["apply", "bind", "call"]);
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow `new` operators with the `Function` object",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-new-func",
+		},
+
+		schema: [],
+
+		messages: {
+			noFunctionConstructor: "The Function constructor is eval.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			"Program:exit"(node) {
+				const globalScope = sourceCode.getScope(node);
+				const variable = globalScope.set.get("Function");
+
+				if (variable && variable.defs.length === 0) {
+					variable.references.forEach(ref => {
+						const idNode = ref.identifier;
+						const { parent } = idNode;
+						let evalNode;
+
+						if (parent) {
+							if (
+								idNode === parent.callee &&
+								(parent.type === "NewExpression" ||
+									parent.type === "CallExpression")
+							) {
+								evalNode = parent;
+							} else if (
+								parent.type === "MemberExpression" &&
+								idNode === parent.object &&
+								callMethods.has(
+									astUtils.getStaticPropertyName(parent),
+								)
+							) {
+								const maybeCallee =
+									parent.parent.type === "ChainExpression"
+										? parent.parent
+										: parent;
+
+								if (
+									maybeCallee.parent.type ===
+										"CallExpression" &&
+									maybeCallee.parent.callee === maybeCallee
+								) {
+									evalNode = maybeCallee.parent;
+								}
+							}
+						}
+
+						if (evalNode) {
+							context.report({
+								node: evalNode,
+								messageId: "noFunctionConstructor",
+							});
+						}
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-new-native-nonconstructor.js

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Rule to disallow use of the new operator with global non-constructor functions
+ * @author Sosuke Suzuki
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const nonConstructorGlobalFunctionNames = ["Symbol", "BigInt"];
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow `new` operators with global non-constructor functions",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor",
+		},
+
+		schema: [],
+
+		messages: {
+			noNewNonconstructor:
+				"`{{name}}` cannot be called as a constructor.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			"Program:exit"(node) {
+				const globalScope = sourceCode.getScope(node);
+
+				for (const nonConstructorName of nonConstructorGlobalFunctionNames) {
+					const variable = globalScope.set.get(nonConstructorName);
+
+					if (variable && variable.defs.length === 0) {
+						variable.references.forEach(ref => {
+							const idNode = ref.identifier;
+							const parent = idNode.parent;
+
+							if (
+								parent &&
+								parent.type === "NewExpression" &&
+								parent.callee === idNode
+							) {
+								context.report({
+									node: idNode,
+									messageId: "noNewNonconstructor",
+									data: { name: nonConstructorName },
+								});
+							}
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-new-object.js

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview A rule to disallow calls to the Object constructor
+ * @author Matt DuVall <http://www.mattduvall.com/>
+ * @deprecated in ESLint v8.50.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow `Object` constructors",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-new-object",
+		},
+
+		deprecated: {
+			message:
+				"The new rule flags more situations where object literal syntax can be used, and it does not report a problem when the `Object` constructor is invoked with an argument.",
+			url: "https://eslint.org/blog/2023/09/eslint-v8.50.0-released/",
+			deprecatedSince: "8.50.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					rule: {
+						name: "no-object-constructor",
+						url: "https://eslint.org/docs/rules/no-object-constructor",
+					},
+				},
+			],
+		},
+
+		schema: [],
+
+		messages: {
+			preferLiteral: "The object literal notation {} is preferable.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			NewExpression(node) {
+				const variable = astUtils.getVariableByName(
+					sourceCode.getScope(node),
+					node.callee.name,
+				);
+
+				if (variable && variable.identifiers.length > 0) {
+					return;
+				}
+
+				if (node.callee.name === "Object") {
+					context.report({
+						node,
+						messageId: "preferLiteral",
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-new-require.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Rule to disallow use of new operator with the `require` function
+ * @author Wil Moore III
+ * @deprecated in ESLint v7.0.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		deprecated: {
+			message: "Node.js rules were moved out of ESLint core.",
+			url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+			deprecatedSince: "7.0.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message:
+						"eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n",
+					},
+					rule: {
+						name: "no-new-require",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-new-require.md",
+					},
+				},
+			],
+		},
+
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow `new` operators with calls to `require`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-new-require",
+		},
+
+		schema: [],
+
+		messages: {
+			noNewRequire: "Unexpected use of new with require.",
+		},
+	},
+
+	create(context) {
+		return {
+			NewExpression(node) {
+				if (
+					node.callee.type === "Identifier" &&
+					node.callee.name === "require"
+				) {
+					context.report({
+						node,
+						messageId: "noNewRequire",
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-new-symbol.js

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview Rule to disallow use of the new operator with the `Symbol` object
+ * @author Alberto Rodríguez
+ * @deprecated in ESLint v9.0.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow `new` operators with the `Symbol` object",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-new-symbol",
+		},
+
+		deprecated: {
+			message: "The rule was replaced with a more general rule.",
+			url: "https://eslint.org/docs/latest/use/migrate-to-9.0.0#eslint-recommended",
+			deprecatedSince: "9.0.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					rule: {
+						name: "no-new-native-nonconstructor",
+						url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor",
+					},
+				},
+			],
+		},
+
+		schema: [],
+
+		messages: {
+			noNewSymbol: "`Symbol` cannot be called as a constructor.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			"Program:exit"(node) {
+				const globalScope = sourceCode.getScope(node);
+				const variable = globalScope.set.get("Symbol");
+
+				if (variable && variable.defs.length === 0) {
+					variable.references.forEach(ref => {
+						const idNode = ref.identifier;
+						const parent = idNode.parent;
+
+						if (
+							parent &&
+							parent.type === "NewExpression" &&
+							parent.callee === idNode
+						) {
+							context.report({
+								node: idNode,
+								messageId: "noNewSymbol",
+							});
+						}
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-new-wrappers.js

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Rule to flag when using constructor for wrapper objects
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { getVariableByName } = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow `new` operators with the `String`, `Number`, and `Boolean` objects",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-new-wrappers",
+		},
+
+		schema: [],
+
+		messages: {
+			noConstructor: "Do not use {{fn}} as a constructor.",
+		},
+	},
+
+	create(context) {
+		const { sourceCode } = context;
+
+		return {
+			NewExpression(node) {
+				const wrapperObjects = ["String", "Number", "Boolean"];
+				const { name } = node.callee;
+
+				if (wrapperObjects.includes(name)) {
+					const variable = getVariableByName(
+						sourceCode.getScope(node),
+						name,
+					);
+
+					if (variable && variable.identifiers.length === 0) {
+						context.report({
+							node,
+							messageId: "noConstructor",
+							data: { fn: name },
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-new.js

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Rule to flag statements with function invocation preceded by
+ * "new" and not part of assignment
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow `new` operators outside of assignments or comparisons",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-new",
+		},
+
+		schema: [],
+
+		messages: {
+			noNewStatement: "Do not use 'new' for side effects.",
+		},
+	},
+
+	create(context) {
+		return {
+			"ExpressionStatement > NewExpression"(node) {
+				context.report({
+					node: node.parent,
+					messageId: "noNewStatement",
+				});
+			},
+		};
+	},
+};