Skip to content
Permalink
9bfb9ba527
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
 
 
Cannot retrieve contributors at this time
122 lines (100 sloc) 4.51 KB
/**
* @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('../shared/types').Rule} */
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;
}
}
}
};
}
};