bahlint 28.58.6934-dev-001

package/lib/rules/no-mixed-operators.js

@@ -0,0 +1,253 @@
+/**
+ * @fileoverview Rule to disallow mixed binary operators.
+ * @author Toru Nagashima
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils.js");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const ARITHMETIC_OPERATORS = ["+", "-", "*", "/", "%", "**"];
+const BITWISE_OPERATORS = ["&", "|", "^", "~", "<<", ">>", ">>>"];
+const COMPARISON_OPERATORS = ["==", "!=", "===", "!==", ">", ">=", "<", "<="];
+const LOGICAL_OPERATORS = ["&&", "||"];
+const RELATIONAL_OPERATORS = ["in", "instanceof"];
+const TERNARY_OPERATOR = ["?:"];
+const COALESCE_OPERATOR = ["??"];
+const ALL_OPERATORS = [].concat(
+	ARITHMETIC_OPERATORS,
+	BITWISE_OPERATORS,
+	COMPARISON_OPERATORS,
+	LOGICAL_OPERATORS,
+	RELATIONAL_OPERATORS,
+	TERNARY_OPERATOR,
+	COALESCE_OPERATOR,
+);
+const DEFAULT_GROUPS = [
+	ARITHMETIC_OPERATORS,
+	BITWISE_OPERATORS,
+	COMPARISON_OPERATORS,
+	LOGICAL_OPERATORS,
+	RELATIONAL_OPERATORS,
+];
+const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u;
+
+/**
+ * Normalizes options.
+ * @param {Object|undefined} options A options object to normalize.
+ * @returns {Object} Normalized option object.
+ */
+function normalizeOptions(options = {}) {
+	const hasGroups = options.groups && options.groups.length > 0;
+	const groups = hasGroups ? options.groups : DEFAULT_GROUPS;
+	const allowSamePrecedence = options.allowSamePrecedence !== false;
+
+	return {
+		groups,
+		allowSamePrecedence,
+	};
+}
+
+/**
+ * Checks whether any group which includes both given operator exists or not.
+ * @param {Array<string[]>} groups A list of groups to check.
+ * @param {string} left An operator.
+ * @param {string} right Another operator.
+ * @returns {boolean} `true` if such group existed.
+ */
+function includesBothInAGroup(groups, left, right) {
+	return groups.some(group => group.includes(left) && group.includes(right));
+}
+
+/**
+ * Checks whether the given node is a conditional expression and returns the test node else the left node.
+ * @param {ASTNode} node A node which can be a BinaryExpression or a LogicalExpression node.
+ * This parent node can be BinaryExpression, LogicalExpression
+ *      , or a ConditionalExpression node
+ * @returns {ASTNode} node the appropriate node(left or test).
+ */
+function getChildNode(node) {
+	return node.type === "ConditionalExpression" ? node.test : node.left;
+}
+
+//------------------------------------------------------------------------------
+// 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: "no-mixed-operators",
+						url: "https://eslint.style/rules/no-mixed-operators",
+					},
+				},
+			],
+		},
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow mixed binary operators",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-mixed-operators",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					groups: {
+						type: "array",
+						items: {
+							type: "array",
+							items: { enum: ALL_OPERATORS },
+							minItems: 2,
+							uniqueItems: true,
+						},
+						uniqueItems: true,
+					},
+					allowSamePrecedence: {
+						type: "boolean",
+						default: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpectedMixedOperator:
+				"Unexpected mix of '{{leftOperator}}' and '{{rightOperator}}'. Use parentheses to clarify the intended order of operations.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = normalizeOptions(context.options[0]);
+
+		/**
+		 * Checks whether a given node should be ignored by options or not.
+		 * @param {ASTNode} node A node to check. This is a BinaryExpression
+		 *      node or a LogicalExpression node. This parent node is one of
+		 *      them, too.
+		 * @returns {boolean} `true` if the node should be ignored.
+		 */
+		function shouldIgnore(node) {
+			const a = node;
+			const b = node.parent;
+
+			return (
+				!includesBothInAGroup(
+					options.groups,
+					a.operator,
+					b.type === "ConditionalExpression" ? "?:" : b.operator,
+				) ||
+				(options.allowSamePrecedence &&
+					astUtils.getPrecedence(a) === astUtils.getPrecedence(b))
+			);
+		}
+
+		/**
+		 * Checks whether the operator of a given node is mixed with parent
+		 * node's operator or not.
+		 * @param {ASTNode} node A node to check. This is a BinaryExpression
+		 *      node or a LogicalExpression node. This parent node is one of
+		 *      them, too.
+		 * @returns {boolean} `true` if the node was mixed.
+		 */
+		function isMixedWithParent(node) {
+			return (
+				node.operator !== node.parent.operator &&
+				!astUtils.isParenthesised(sourceCode, node)
+			);
+		}
+
+		/**
+		 * Gets the operator token of a given node.
+		 * @param {ASTNode} node A node to check. This is a BinaryExpression
+		 *      node or a LogicalExpression node.
+		 * @returns {Token} The operator token of the node.
+		 */
+		function getOperatorToken(node) {
+			return sourceCode.getTokenAfter(
+				getChildNode(node),
+				astUtils.isNotClosingParenToken,
+			);
+		}
+
+		/**
+		 * Reports both the operator of a given node and the operator of the
+		 * parent node.
+		 * @param {ASTNode} node A node to check. This is a BinaryExpression
+		 *      node or a LogicalExpression node. This parent node is one of
+		 *      them, too.
+		 * @returns {void}
+		 */
+		function reportBothOperators(node) {
+			const parent = node.parent;
+			const left = getChildNode(parent) === node ? node : parent;
+			const right = getChildNode(parent) !== node ? node : parent;
+			const data = {
+				leftOperator: left.operator || "?:",
+				rightOperator: right.operator || "?:",
+			};
+
+			context.report({
+				node: left,
+				loc: getOperatorToken(left).loc,
+				messageId: "unexpectedMixedOperator",
+				data,
+			});
+			context.report({
+				node: right,
+				loc: getOperatorToken(right).loc,
+				messageId: "unexpectedMixedOperator",
+				data,
+			});
+		}
+
+		/**
+		 * Checks between the operator of this node and the operator of the
+		 * parent node.
+		 * @param {ASTNode} node A node to check.
+		 * @returns {void}
+		 */
+		function check(node) {
+			if (
+				TARGET_NODE_TYPE.test(node.parent.type) &&
+				isMixedWithParent(node) &&
+				!shouldIgnore(node)
+			) {
+				reportBothOperators(node);
+			}
+		}
+
+		return {
+			BinaryExpression: check,
+			LogicalExpression: check,
+		};
+	},
+};

package/lib/rules/no-mixed-requires.js

@@ -0,0 +1,267 @@
+/**
+ * @fileoverview Rule to enforce grouped require statements for Node.JS
+ * @author Raphael Pigulla
+ * @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-mixed-requires",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-mixed-requires.md",
+					},
+				},
+			],
+		},
+
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow `require` calls to be mixed with regular variable declarations",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-mixed-requires",
+		},
+
+		schema: [
+			{
+				oneOf: [
+					{
+						type: "boolean",
+					},
+					{
+						type: "object",
+						properties: {
+							grouping: {
+								type: "boolean",
+							},
+							allowCall: {
+								type: "boolean",
+							},
+						},
+						additionalProperties: false,
+					},
+				],
+			},
+		],
+
+		messages: {
+			noMixRequire: "Do not mix 'require' and other declarations.",
+			noMixCoreModuleFileComputed:
+				"Do not mix core, module, file and computed requires.",
+		},
+	},
+
+	create(context) {
+		const options = context.options[0];
+		let grouping = false,
+			allowCall = false;
+
+		if (typeof options === "object") {
+			grouping = options.grouping;
+			allowCall = options.allowCall;
+		} else {
+			grouping = !!options;
+		}
+
+		/**
+		 * Returns the list of built-in modules.
+		 * @returns {string[]} An array of built-in Node.js modules.
+		 */
+		function getBuiltinModules() {
+			/*
+			 * This list is generated using:
+			 * `require("repl")._builtinLibs.concat('repl').sort()`
+			 * This particular list is as per nodejs v0.12.2 and iojs v0.7.1
+			 */
+			return [
+				"assert",
+				"buffer",
+				"child_process",
+				"cluster",
+				"crypto",
+				"dgram",
+				"dns",
+				"domain",
+				"events",
+				"fs",
+				"http",
+				"https",
+				"net",
+				"os",
+				"path",
+				"punycode",
+				"querystring",
+				"readline",
+				"repl",
+				"smalloc",
+				"stream",
+				"string_decoder",
+				"tls",
+				"tty",
+				"url",
+				"util",
+				"v8",
+				"vm",
+				"zlib",
+			];
+		}
+
+		const BUILTIN_MODULES = getBuiltinModules();
+
+		const DECL_REQUIRE = "require",
+			DECL_UNINITIALIZED = "uninitialized",
+			DECL_OTHER = "other";
+
+		const REQ_CORE = "core",
+			REQ_FILE = "file",
+			REQ_MODULE = "module",
+			REQ_COMPUTED = "computed";
+
+		/**
+		 * Determines the type of a declaration statement.
+		 * @param {ASTNode} initExpression The init node of the VariableDeclarator.
+		 * @returns {string} The type of declaration represented by the expression.
+		 */
+		function getDeclarationType(initExpression) {
+			if (!initExpression) {
+				// "var x;"
+				return DECL_UNINITIALIZED;
+			}
+
+			if (
+				initExpression.type === "CallExpression" &&
+				initExpression.callee.type === "Identifier" &&
+				initExpression.callee.name === "require"
+			) {
+				// "var x = require('util');"
+				return DECL_REQUIRE;
+			}
+			if (
+				allowCall &&
+				initExpression.type === "CallExpression" &&
+				initExpression.callee.type === "CallExpression"
+			) {
+				// "var x = require('diagnose')('sub-module');"
+				return getDeclarationType(initExpression.callee);
+			}
+			if (initExpression.type === "MemberExpression") {
+				// "var x = require('glob').Glob;"
+				return getDeclarationType(initExpression.object);
+			}
+
+			// "var x = 42;"
+			return DECL_OTHER;
+		}
+
+		/**
+		 * Determines the type of module that is loaded via require.
+		 * @param {ASTNode} initExpression The init node of the VariableDeclarator.
+		 * @returns {string} The module type.
+		 */
+		function inferModuleType(initExpression) {
+			if (initExpression.type === "MemberExpression") {
+				// "var x = require('glob').Glob;"
+				return inferModuleType(initExpression.object);
+			}
+			if (initExpression.arguments.length === 0) {
+				// "var x = require();"
+				return REQ_COMPUTED;
+			}
+
+			const arg = initExpression.arguments[0];
+
+			if (arg.type !== "Literal" || typeof arg.value !== "string") {
+				// "var x = require(42);"
+				return REQ_COMPUTED;
+			}
+
+			if (BUILTIN_MODULES.includes(arg.value)) {
+				// "var fs = require('fs');"
+				return REQ_CORE;
+			}
+			if (/^\.{0,2}\//u.test(arg.value)) {
+				// "var utils = require('./utils');"
+				return REQ_FILE;
+			}
+
+			// "var async = require('async');"
+			return REQ_MODULE;
+		}
+
+		/**
+		 * Check if the list of variable declarations is mixed, i.e. whether it
+		 * contains both require and other declarations.
+		 * @param {ASTNode} declarations The list of VariableDeclarators.
+		 * @returns {boolean} True if the declarations are mixed, false if not.
+		 */
+		function isMixed(declarations) {
+			const contains = {};
+
+			declarations.forEach(declaration => {
+				const type = getDeclarationType(declaration.init);
+
+				contains[type] = true;
+			});
+
+			return !!(
+				contains[DECL_REQUIRE] &&
+				(contains[DECL_UNINITIALIZED] || contains[DECL_OTHER])
+			);
+		}
+
+		/**
+		 * Check if all require declarations in the given list are of the same
+		 * type.
+		 * @param {ASTNode} declarations The list of VariableDeclarators.
+		 * @returns {boolean} True if the declarations are grouped, false if not.
+		 */
+		function isGrouped(declarations) {
+			const found = {};
+
+			declarations.forEach(declaration => {
+				if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
+					found[inferModuleType(declaration.init)] = true;
+				}
+			});
+
+			return Object.keys(found).length <= 1;
+		}
+
+		return {
+			VariableDeclaration(node) {
+				if (isMixed(node.declarations)) {
+					context.report({
+						node,
+						messageId: "noMixRequire",
+					});
+				} else if (grouping && !isGrouped(node.declarations)) {
+					context.report({
+						node,
+						messageId: "noMixCoreModuleFileComputed",
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-mixed-spaces-and-tabs.js

@@ -0,0 +1,148 @@
+/**
+ * @fileoverview Disallow mixed spaces and tabs for indentation
+ * @author Jary Niebur
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// 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: "no-mixed-spaces-and-tabs",
+						url: "https://eslint.style/rules/no-mixed-spaces-and-tabs",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Disallow mixed spaces and tabs for indentation",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs",
+		},
+
+		schema: [
+			{
+				enum: ["smart-tabs", true, false],
+			},
+		],
+
+		messages: {
+			mixedSpacesAndTabs: "Mixed spaces and tabs.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		let smartTabs;
+
+		switch (context.options[0]) {
+			case true: // Support old syntax, maybe add deprecation warning here
+			case "smart-tabs":
+				smartTabs = true;
+				break;
+			default:
+				smartTabs = false;
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			"Program:exit"(node) {
+				const lines = sourceCode.lines,
+					comments = sourceCode.getAllComments(),
+					ignoredCommentLines = new Set();
+
+				// Add all lines except the first ones.
+				comments.forEach(comment => {
+					for (
+						let i = comment.loc.start.line + 1;
+						i <= comment.loc.end.line;
+						i++
+					) {
+						ignoredCommentLines.add(i);
+					}
+				});
+
+				/*
+				 * At least one space followed by a tab
+				 * or the reverse before non-tab/-space
+				 * characters begin.
+				 */
+				let regex = /^(?=( +|\t+))\1(?:\t| )/u;
+
+				if (smartTabs) {
+					/*
+					 * At least one space followed by a tab
+					 * before non-tab/-space characters begin.
+					 */
+					// eslint-disable-next-line regexp/no-empty-lookarounds-assertion -- False positive
+					regex = /^(?=(\t*))\1(?=( +))\2\t/u;
+				}
+
+				lines.forEach((line, i) => {
+					const match = regex.exec(line);
+
+					if (match) {
+						const lineNumber = i + 1;
+						const loc = {
+							start: {
+								line: lineNumber,
+								column: match[0].length - 2,
+							},
+							end: {
+								line: lineNumber,
+								column: match[0].length,
+							},
+						};
+
+						if (!ignoredCommentLines.has(lineNumber)) {
+							const containingNode =
+								sourceCode.getNodeByRangeIndex(
+									sourceCode.getIndexFromLoc(loc.start),
+								);
+
+							if (
+								!(
+									containingNode &&
+									["Literal", "TemplateElement"].includes(
+										containingNode.type,
+									)
+								)
+							) {
+								context.report({
+									node,
+									loc,
+									messageId: "mixedSpacesAndTabs",
+								});
+							}
+						}
+					}
+				});
+			},
+		};
+	},
+};