bahlint 28.58.6934

package/lib/rules/no-dupe-class-members.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview A rule to disallow duplicate name in class members.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
+
+		docs: {
+			description: "Disallow duplicate class members",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-dupe-class-members",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpected: "Duplicate name '{{name}}'.",
+		},
+	},
+
+	create(context) {
+		let stack = [];
+
+		/**
+		 * Gets state of a given member name.
+		 * @param {string} name A name of a member.
+		 * @param {boolean} isStatic A flag which specifies that is a static member.
+		 * @returns {Object} A state of a given member name.
+		 *   - retv.init {boolean} A flag which shows the name is declared as normal member.
+		 *   - retv.get {boolean} A flag which shows the name is declared as getter.
+		 *   - retv.set {boolean} A flag which shows the name is declared as setter.
+		 */
+		function getState(name, isStatic) {
+			const stateMap = stack.at(-1);
+			const key = `$${name}`; // to avoid "__proto__".
+
+			if (!stateMap[key]) {
+				stateMap[key] = {
+					nonStatic: { init: false, get: false, set: false },
+					static: { init: false, get: false, set: false },
+				};
+			}
+
+			return stateMap[key][isStatic ? "static" : "nonStatic"];
+		}
+
+		return {
+			// Initializes the stack of state of member declarations.
+			Program() {
+				stack = [];
+			},
+
+			// Initializes state of member declarations for the class.
+			ClassBody() {
+				stack.push(Object.create(null));
+			},
+
+			// Disposes the state for the class.
+			"ClassBody:exit"() {
+				stack.pop();
+			},
+
+			// Reports the node if its name has been declared already.
+			"MethodDefinition, PropertyDefinition"(node) {
+				if (
+					node.value &&
+					node.value.type === "TSEmptyBodyFunctionExpression"
+				) {
+					return;
+				}
+
+				const name = astUtils.getStaticPropertyName(node);
+				const kind =
+					node.type === "MethodDefinition" ? node.kind : "field";
+
+				if (name === null || kind === "constructor") {
+					return;
+				}
+
+				const state = getState(name, node.static);
+				let isDuplicate;
+
+				if (kind === "get") {
+					isDuplicate = state.init || state.get;
+					state.get = true;
+				} else if (kind === "set") {
+					isDuplicate = state.init || state.set;
+					state.set = true;
+				} else {
+					isDuplicate = state.init || state.get || state.set;
+					state.init = true;
+				}
+
+				if (isDuplicate) {
+					context.report({
+						loc: node.key.loc,
+						messageId: "unexpected",
+						data: { name },
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-dupe-else-if.js

@@ -0,0 +1,145 @@
+/**
+ * @fileoverview Rule to disallow duplicate conditions in if-else-if chains
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the first given array is a subset of the second given array.
+ * @param {Function} comparator A function to compare two elements, should return `true` if they are equal.
+ * @param {Array} arrA The array to compare from.
+ * @param {Array} arrB The array to compare against.
+ * @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`.
+ */
+function isSubsetByComparator(comparator, arrA, arrB) {
+	return arrA.every(a => arrB.some(b => comparator(a, b)));
+}
+
+/**
+ * Splits the given node by the given logical operator.
+ * @param {string} operator Logical operator `||` or `&&`.
+ * @param {ASTNode} node The node to split.
+ * @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator.
+ */
+function splitByLogicalOperator(operator, node) {
+	if (node.type === "LogicalExpression" && node.operator === operator) {
+		return [
+			...splitByLogicalOperator(operator, node.left),
+			...splitByLogicalOperator(operator, node.right),
+		];
+	}
+	return [node];
+}
+
+const splitByOr = splitByLogicalOperator.bind(null, "||");
+const splitByAnd = splitByLogicalOperator.bind(null, "&&");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow duplicate conditions in if-else-if chains",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-dupe-else-if",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpected:
+				"This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Determines whether the two given nodes are considered to be equal. In particular, given that the nodes
+		 * represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators.
+		 * @param {ASTNode} a First node.
+		 * @param {ASTNode} b Second node.
+		 * @returns {boolean} `true` if the nodes are considered to be equal.
+		 */
+		function equal(a, b) {
+			if (a.type !== b.type) {
+				return false;
+			}
+
+			if (
+				a.type === "LogicalExpression" &&
+				(a.operator === "||" || a.operator === "&&") &&
+				a.operator === b.operator
+			) {
+				return (
+					(equal(a.left, b.left) && equal(a.right, b.right)) ||
+					(equal(a.left, b.right) && equal(a.right, b.left))
+				);
+			}
+
+			return astUtils.equalTokens(a, b, sourceCode);
+		}
+
+		const isSubset = isSubsetByComparator.bind(null, equal);
+
+		return {
+			IfStatement(node) {
+				const test = node.test,
+					conditionsToCheck =
+						test.type === "LogicalExpression" &&
+						test.operator === "&&"
+							? [test, ...splitByAnd(test)]
+							: [test];
+				let current = node,
+					listToCheck = conditionsToCheck.map(c =>
+						splitByOr(c).map(splitByAnd),
+					);
+
+				while (
+					current.parent &&
+					current.parent.type === "IfStatement" &&
+					current.parent.alternate === current
+				) {
+					current = current.parent;
+
+					const currentOrOperands = splitByOr(current.test).map(
+						splitByAnd,
+					);
+
+					listToCheck = listToCheck.map(orOperands =>
+						orOperands.filter(
+							orOperand =>
+								!currentOrOperands.some(currentOrOperand =>
+									isSubset(currentOrOperand, orOperand),
+								),
+						),
+					);
+
+					if (
+						listToCheck.some(orOperands => orOperands.length === 0)
+					) {
+						context.report({ node: test, messageId: "unexpected" });
+						break;
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-dupe-keys.js

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview Rule to flag use of duplicate keys in an object.
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const GET_KIND = /^(?:init|get)$/u;
+const SET_KIND = /^(?:init|set)$/u;
+
+/**
+ * The class which stores properties' information of an object.
+ */
+class ObjectInfo {
+	/**
+	 * @param {ObjectInfo|null} upper The information of the outer object.
+	 * @param {ASTNode} node The ObjectExpression node of this information.
+	 */
+	constructor(upper, node) {
+		this.upper = upper;
+		this.node = node;
+		this.properties = new Map();
+	}
+
+	/**
+	 * Gets the information of the given Property node.
+	 * @param {ASTNode} node The Property node to get.
+	 * @returns {{get: boolean, set: boolean}} The information of the property.
+	 */
+	getPropertyInfo(node) {
+		const name = astUtils.getStaticPropertyName(node);
+
+		if (!this.properties.has(name)) {
+			this.properties.set(name, { get: false, set: false });
+		}
+		return this.properties.get(name);
+	}
+
+	/**
+	 * Checks whether the given property has been defined already or not.
+	 * @param {ASTNode} node The Property node to check.
+	 * @returns {boolean} `true` if the property has been defined.
+	 */
+	isPropertyDefined(node) {
+		const entry = this.getPropertyInfo(node);
+
+		return (
+			(GET_KIND.test(node.kind) && entry.get) ||
+			(SET_KIND.test(node.kind) && entry.set)
+		);
+	}
+
+	/**
+	 * Defines the given property.
+	 * @param {ASTNode} node The Property node to define.
+	 * @returns {void}
+	 */
+	defineProperty(node) {
+		const entry = this.getPropertyInfo(node);
+
+		if (GET_KIND.test(node.kind)) {
+			entry.get = true;
+		}
+		if (SET_KIND.test(node.kind)) {
+			entry.set = true;
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow duplicate keys in object literals",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-dupe-keys",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpected: "Duplicate key '{{name}}'.",
+		},
+	},
+
+	create(context) {
+		let info = null;
+
+		return {
+			ObjectExpression(node) {
+				info = new ObjectInfo(info, node);
+			},
+			"ObjectExpression:exit"() {
+				info = info.upper;
+			},
+
+			Property(node) {
+				const name = astUtils.getStaticPropertyName(node);
+
+				// Skip destructuring.
+				if (node.parent.type !== "ObjectExpression") {
+					return;
+				}
+
+				// Skip if the name is not static.
+				if (name === null) {
+					return;
+				}
+
+				/*
+				 * Skip if the property node is a proto setter.
+				 * Proto setter is a special syntax that sets
+				 * object's prototype instead of creating a property.
+				 * It can be in one of the following forms:
+				 *
+				 *    __proto__: <expression>
+				 *    '__proto__': <expression>
+				 *    "__proto__": <expression>
+				 *
+				 * Duplicate proto setters produce parsing errors,
+				 * so we can just skip them to not interfere with
+				 * regular properties named "__proto__".
+				 */
+				if (
+					name === "__proto__" &&
+					node.kind === "init" &&
+					!node.computed &&
+					!node.shorthand &&
+					!node.method
+				) {
+					return;
+				}
+
+				// Reports if the name is defined already.
+				if (info.isPropertyDefined(node)) {
+					context.report({
+						node: info.node,
+						loc: node.key.loc,
+						messageId: "unexpected",
+						data: { name },
+					});
+				}
+
+				// Update info.
+				info.defineProperty(node);
+			},
+		};
+	},
+};

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

@@ -0,0 +1,78 @@
+/**
+ * @fileoverview Rule to disallow a duplicate case label.
+ * @author Dieter Oberkofler
+ * @author Burak Yigit Kaya
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow duplicate case labels",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-duplicate-case",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpected: "Duplicate case label.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Determines whether the two given nodes are considered to be equal.
+		 * @param {ASTNode} a First node.
+		 * @param {ASTNode} b Second node.
+		 * @returns {boolean} `true` if the nodes are considered to be equal.
+		 */
+		function equal(a, b) {
+			if (a.type !== b.type) {
+				return false;
+			}
+
+			return astUtils.equalTokens(a, b, sourceCode);
+		}
+		return {
+			SwitchStatement(node) {
+				const previousTests = [];
+
+				for (const switchCase of node.cases) {
+					if (switchCase.test) {
+						const test = switchCase.test;
+
+						if (
+							previousTests.some(previousTest =>
+								equal(previousTest, test),
+							)
+						) {
+							context.report({
+								node: switchCase,
+								messageId: "unexpected",
+							});
+						} else {
+							previousTests.push(test);
+						}
+					}
+				}
+			},
+		};
+	},
+};