1 | /**
|
2 | * @fileoverview Rule to disallow duplicate conditions in if-else-if chains
|
3 | * @author Milos Djermanovic
|
4 | */
|
5 |
|
6 | ;
|
7 |
|
8 | //------------------------------------------------------------------------------
|
9 | // Requirements
|
10 | //------------------------------------------------------------------------------
|
11 |
|
12 | const astUtils = require("./utils/ast-utils");
|
13 |
|
14 | //------------------------------------------------------------------------------
|
15 | // Helpers
|
16 | //------------------------------------------------------------------------------
|
17 |
|
18 | /**
|
19 | * Determines whether the first given array is a subset of the second given array.
|
20 | * @param {Function} comparator A function to compare two elements, should return `true` if they are equal.
|
21 | * @param {Array} arrA The array to compare from.
|
22 | * @param {Array} arrB The array to compare against.
|
23 | * @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`.
|
24 | */
|
25 | function isSubsetByComparator(comparator, arrA, arrB) {
|
26 | return arrA.every(a => arrB.some(b => comparator(a, b)));
|
27 | }
|
28 |
|
29 | /**
|
30 | * Splits the given node by the given logical operator.
|
31 | * @param {string} operator Logical operator `||` or `&&`.
|
32 | * @param {ASTNode} node The node to split.
|
33 | * @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator.
|
34 | */
|
35 | function splitByLogicalOperator(operator, node) {
|
36 | if (node.type === "LogicalExpression" && node.operator === operator) {
|
37 | return [...splitByLogicalOperator(operator, node.left), ...splitByLogicalOperator(operator, node.right)];
|
38 | }
|
39 | return [node];
|
40 | }
|
41 |
|
42 | const splitByOr = splitByLogicalOperator.bind(null, "||");
|
43 | const splitByAnd = splitByLogicalOperator.bind(null, "&&");
|
44 |
|
45 | //------------------------------------------------------------------------------
|
46 | // Rule Definition
|
47 | //------------------------------------------------------------------------------
|
48 |
|
49 | module.exports = {
|
50 | meta: {
|
51 | type: "problem",
|
52 |
|
53 | docs: {
|
54 | description: "disallow duplicate conditions in if-else-if chains",
|
55 | category: "Possible Errors",
|
56 | recommended: true,
|
57 | url: "https://eslint.org/docs/rules/no-dupe-else-if"
|
58 | },
|
59 |
|
60 | schema: [],
|
61 |
|
62 | messages: {
|
63 | unexpected: "This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain."
|
64 | }
|
65 | },
|
66 |
|
67 | create(context) {
|
68 | const sourceCode = context.getSourceCode();
|
69 |
|
70 | /**
|
71 | * Determines whether the two given nodes are considered to be equal. In particular, given that the nodes
|
72 | * represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators.
|
73 | * @param {ASTNode} a First node.
|
74 | * @param {ASTNode} b Second node.
|
75 | * @returns {boolean} `true` if the nodes are considered to be equal.
|
76 | */
|
77 | function equal(a, b) {
|
78 | if (a.type !== b.type) {
|
79 | return false;
|
80 | }
|
81 |
|
82 | if (
|
83 | a.type === "LogicalExpression" &&
|
84 | (a.operator === "||" || a.operator === "&&") &&
|
85 | a.operator === b.operator
|
86 | ) {
|
87 | return equal(a.left, b.left) && equal(a.right, b.right) ||
|
88 | equal(a.left, b.right) && equal(a.right, b.left);
|
89 | }
|
90 |
|
91 | return astUtils.equalTokens(a, b, sourceCode);
|
92 | }
|
93 |
|
94 | const isSubset = isSubsetByComparator.bind(null, equal);
|
95 |
|
96 | return {
|
97 | IfStatement(node) {
|
98 | const test = node.test,
|
99 | conditionsToCheck = test.type === "LogicalExpression" && test.operator === "&&"
|
100 | ? [test, ...splitByAnd(test)]
|
101 | : [test];
|
102 | let current = node,
|
103 | listToCheck = conditionsToCheck.map(c => splitByOr(c).map(splitByAnd));
|
104 |
|
105 | while (current.parent && current.parent.type === "IfStatement" && current.parent.alternate === current) {
|
106 | current = current.parent;
|
107 |
|
108 | const currentOrOperands = splitByOr(current.test).map(splitByAnd);
|
109 |
|
110 | listToCheck = listToCheck.map(orOperands => orOperands.filter(
|
111 | orOperand => !currentOrOperands.some(currentOrOperand => isSubset(currentOrOperand, orOperand))
|
112 | ));
|
113 |
|
114 | if (listToCheck.some(orOperands => orOperands.length === 0)) {
|
115 | context.report({ node: test, messageId: "unexpected" });
|
116 | break;
|
117 | }
|
118 | }
|
119 | }
|
120 | };
|
121 | }
|
122 | };
|