vscode-extension--copy-words-to-clipboard/hover-words-to-copy/node_modules/eslint/lib/rules/no-dupe-else-if.js

/**
 * @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;
					}
				}
			},
		};
	},
};