bahlint 28.58.6934-dev-001

package/lib/rules/no-buffer-constructor.js

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview disallow use of the Buffer() constructor
+ * @author Teddy Katz
+ * @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-deprecated-api",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-deprecated-api.md",
+					},
+				},
+			],
+		},
+
+		type: "problem",
+
+		docs: {
+			description: "Disallow use of the `Buffer()` constructor",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-buffer-constructor",
+		},
+
+		schema: [],
+
+		messages: {
+			deprecated:
+				"{{expr}} is deprecated. Use Buffer.from(), Buffer.alloc(), or Buffer.allocUnsafe() instead.",
+		},
+	},
+
+	create(context) {
+		//----------------------------------------------------------------------
+		// Public
+		//----------------------------------------------------------------------
+
+		return {
+			"CallExpression[callee.name='Buffer'], NewExpression[callee.name='Buffer']"(
+				node,
+			) {
+				context.report({
+					node,
+					messageId: "deprecated",
+					data: {
+						expr:
+							node.type === "CallExpression"
+								? "Buffer()"
+								: "new Buffer()",
+					},
+				});
+			},
+		};
+	},
+};

package/lib/rules/no-caller.js

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Rule to flag use of arguments.callee and arguments.caller.
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow the use of `arguments.caller` or `arguments.callee`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-caller",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpected: "Avoid arguments.{{prop}}.",
+		},
+	},
+
+	create(context) {
+		return {
+			MemberExpression(node) {
+				const objectName = node.object.name,
+					propertyName = node.property.name;
+
+				if (
+					objectName === "arguments" &&
+					!node.computed &&
+					propertyName &&
+					propertyName.match(/^calle[er]$/u)
+				) {
+					context.report({
+						node,
+						messageId: "unexpected",
+						data: { prop: propertyName },
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-case-declarations.js

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Rule to flag use of an lexical declarations inside a case clause
+ * @author Erik Arvidsson
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow lexical declarations in case clauses",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-case-declarations",
+		},
+
+		hasSuggestions: true,
+
+		schema: [],
+
+		messages: {
+			addBrackets: "Add {} brackets around the case block.",
+			unexpected: "Unexpected lexical declaration in case block.",
+		},
+	},
+
+	create(context) {
+		/**
+		 * Checks whether or not a node is a lexical declaration.
+		 * @param {ASTNode} node A direct child statement of a switch case.
+		 * @returns {boolean} Whether or not the node is a lexical declaration.
+		 */
+		function isLexicalDeclaration(node) {
+			switch (node.type) {
+				case "FunctionDeclaration":
+				case "ClassDeclaration":
+					return true;
+				case "VariableDeclaration":
+					return node.kind !== "var";
+				default:
+					return false;
+			}
+		}
+
+		return {
+			SwitchCase(node) {
+				for (let i = 0; i < node.consequent.length; i++) {
+					const statement = node.consequent[i];
+
+					if (isLexicalDeclaration(statement)) {
+						context.report({
+							node: statement,
+							messageId: "unexpected",
+							suggest: [
+								{
+									messageId: "addBrackets",
+									fix: fixer => [
+										fixer.insertTextBefore(
+											node.consequent[0],
+											"{ ",
+										),
+										fixer.insertTextAfter(
+											node.consequent.at(-1),
+											" }",
+										),
+									],
+								},
+							],
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-catch-shadow.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview Rule to flag variable leak in CatchClauses in IE 8 and earlier
+ * @author Ian Christian Myers
+ * @deprecated in ESLint v5.1.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 `catch` clause parameters from shadowing variables in the outer scope",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-catch-shadow",
+		},
+
+		deprecated: {
+			message: "This rule was renamed.",
+			url: "https://eslint.org/blog/2018/07/eslint-v5.1.0-released/",
+			deprecatedSince: "5.1.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					rule: {
+						name: "no-shadow",
+						url: "https://eslint.org/docs/rules/no-shadow",
+					},
+				},
+			],
+		},
+		schema: [],
+
+		messages: {
+			mutable:
+				"Value of '{{name}}' may be overwritten in IE 8 and earlier.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Check if the parameters are been shadowed
+		 * @param {Object} scope current scope
+		 * @param {string} name parameter name
+		 * @returns {boolean} True is its been shadowed
+		 */
+		function paramIsShadowing(scope, name) {
+			return astUtils.getVariableByName(scope, name) !== null;
+		}
+
+		//--------------------------------------------------------------------------
+		// Public API
+		//--------------------------------------------------------------------------
+
+		return {
+			"CatchClause[param!=null]"(node) {
+				let scope = sourceCode.getScope(node);
+
+				/*
+				 * When ecmaVersion >= 6, CatchClause creates its own scope
+				 * so start from one upper scope to exclude the current node
+				 */
+				if (scope.block === node) {
+					scope = scope.upper;
+				}
+
+				if (paramIsShadowing(scope, node.param.name)) {
+					context.report({
+						node,
+						messageId: "mutable",
+						data: { name: node.param.name },
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-class-assign.js

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview A rule to disallow modifying variables of class declarations
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow reassigning class members",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-class-assign",
+		},
+
+		schema: [],
+
+		messages: {
+			class: "'{{name}}' is a class.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Finds and reports references that are non initializer and writable.
+		 * @param {Variable} variable A variable to check.
+		 * @returns {void}
+		 */
+		function checkVariable(variable) {
+			astUtils
+				.getModifyingReferences(variable.references)
+				.forEach(reference => {
+					context.report({
+						node: reference.identifier,
+						messageId: "class",
+						data: { name: reference.identifier.name },
+					});
+				});
+		}
+
+		/**
+		 * Finds and reports references that are non initializer and writable.
+		 * @param {ASTNode} node A ClassDeclaration/ClassExpression node to check.
+		 * @returns {void}
+		 */
+		function checkForClass(node) {
+			sourceCode.getDeclaredVariables(node).forEach(checkVariable);
+		}
+
+		return {
+			ClassDeclaration: checkForClass,
+			ClassExpression: checkForClass,
+		};
+	},
+};

package/lib/rules/no-compare-neg-zero.js

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview The rule should warn against code that tries to compare against -0.
+ * @author Aladdin-ADD <hh_2013@foxmail.com>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow comparing against `-0`",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-compare-neg-zero",
+		},
+
+		fixable: null,
+		schema: [],
+
+		messages: {
+			unexpected:
+				"Do not use the '{{operator}}' operator to compare against -0.",
+		},
+	},
+
+	create(context) {
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Checks a given node is -0
+		 * @param {ASTNode} node A node to check.
+		 * @returns {boolean} `true` if the node is -0.
+		 */
+		function isNegZero(node) {
+			return (
+				node.type === "UnaryExpression" &&
+				node.operator === "-" &&
+				node.argument.type === "Literal" &&
+				node.argument.value === 0
+			);
+		}
+		const OPERATORS_TO_CHECK = new Set([
+			">",
+			">=",
+			"<",
+			"<=",
+			"==",
+			"===",
+			"!=",
+			"!==",
+		]);
+
+		return {
+			BinaryExpression(node) {
+				if (OPERATORS_TO_CHECK.has(node.operator)) {
+					if (isNegZero(node.left) || isNegZero(node.right)) {
+						context.report({
+							node,
+							messageId: "unexpected",
+							data: { operator: node.operator },
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-cond-assign.js

@@ -0,0 +1,175 @@
+/**
+ * @fileoverview Rule to flag assignment in a conditional statement's test expression
+ * @author Stephen Murray <spmurrayzzz>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const TEST_CONDITION_PARENT_TYPES = new Set([
+	"IfStatement",
+	"WhileStatement",
+	"DoWhileStatement",
+	"ForStatement",
+	"ConditionalExpression",
+]);
+
+const NODE_DESCRIPTIONS = {
+	DoWhileStatement: "a 'do...while' statement",
+	ForStatement: "a 'for' statement",
+	IfStatement: "an 'if' statement",
+	WhileStatement: "a 'while' statement",
+};
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		defaultOptions: ["except-parens"],
+
+		docs: {
+			description:
+				"Disallow assignment operators in conditional expressions",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-cond-assign",
+		},
+
+		schema: [
+			{
+				enum: ["except-parens", "always"],
+			},
+		],
+
+		messages: {
+			unexpected: "Unexpected assignment within {{type}}.",
+
+			// must match JSHint's error message
+			missing:
+				"Expected a conditional expression and instead saw an assignment.",
+		},
+	},
+
+	create(context) {
+		const [prohibitAssign] = context.options;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Check whether an AST node is the test expression for a conditional statement.
+		 * @param {!Object} node The node to test.
+		 * @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.
+		 */
+		function isConditionalTestExpression(node) {
+			return (
+				node.parent &&
+				TEST_CONDITION_PARENT_TYPES.has(node.parent.type) &&
+				node === node.parent.test
+			);
+		}
+
+		/**
+		 * Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.
+		 * @param {!Object} node The node to use at the start of the search.
+		 * @returns {?Object} The closest ancestor node that represents a conditional statement.
+		 */
+		function findConditionalAncestor(node) {
+			let currentAncestor = node;
+
+			do {
+				if (isConditionalTestExpression(currentAncestor)) {
+					return currentAncestor.parent;
+				}
+			} while (
+				(currentAncestor = currentAncestor.parent) &&
+				!astUtils.isFunction(currentAncestor)
+			);
+
+			return null;
+		}
+
+		/**
+		 * Check whether the code represented by an AST node is enclosed in two sets of parentheses.
+		 * @param {!Object} node The node to test.
+		 * @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.
+		 */
+		function isParenthesisedTwice(node) {
+			const previousToken = sourceCode.getTokenBefore(node, 1),
+				nextToken = sourceCode.getTokenAfter(node, 1);
+
+			return (
+				astUtils.isParenthesised(sourceCode, node) &&
+				previousToken &&
+				astUtils.isOpeningParenToken(previousToken) &&
+				previousToken.range[1] <= node.range[0] &&
+				astUtils.isClosingParenToken(nextToken) &&
+				nextToken.range[0] >= node.range[1]
+			);
+		}
+
+		/**
+		 * Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.
+		 * @param {!Object} node The node for the conditional statement.
+		 * @returns {void}
+		 */
+		function testForAssign(node) {
+			if (
+				node.test &&
+				node.test.type === "AssignmentExpression" &&
+				(node.type === "ForStatement"
+					? !astUtils.isParenthesised(sourceCode, node.test)
+					: !isParenthesisedTwice(node.test))
+			) {
+				context.report({
+					node: node.test,
+					messageId: "missing",
+				});
+			}
+		}
+
+		/**
+		 * Check whether an assignment expression is descended from a conditional statement's test expression.
+		 * @param {!Object} node The node for the assignment expression.
+		 * @returns {void}
+		 */
+		function testForConditionalAncestor(node) {
+			const ancestor = findConditionalAncestor(node);
+
+			if (ancestor) {
+				context.report({
+					node,
+					messageId: "unexpected",
+					data: {
+						type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type,
+					},
+				});
+			}
+		}
+
+		if (prohibitAssign === "always") {
+			return {
+				AssignmentExpression: testForConditionalAncestor,
+			};
+		}
+
+		return {
+			DoWhileStatement: testForAssign,
+			ForStatement: testForAssign,
+			IfStatement: testForAssign,
+			WhileStatement: testForAssign,
+			ConditionalExpression: testForAssign,
+		};
+	},
+};