Path 1: 502 calls (0.44)

→ node Compare (502)

7 run 7 not run

1def _check_logical_tautology(self, node: nodes.Compare) -> None:
2        """Check if identifier is compared against itself.
3
4        :param node: Compare node
5        :Example:
6        val = 786
7        if val == val:  # [comparison-with-itself]
8            pass
9        """
10        left_operand = node.left
11        right_operand = node.ops[0][1]
12        operator = node.ops[0][0]
13        if isinstance(left_operand, nodes.Const) and isinstance(
14            right_operand, nodes.Const
15        ):
16            left_operand = left_operand.value
17            right_operand = right_operand.value
18        elif isinstance(left_operand, nodes.Name) and isinstance(
19            right_operand, nodes.Name
20        ):
21            left_operand = left_operand.name
22            right_operand = right_operand.name
23
24        if left_operand == right_operand:
25            suggestion = f"{left_operand} {operator} {right_operand}"
26            self.add_message("comparison-with-itself", node=node, args=(suggestion,))
            

Path 2: 279 calls (0.24)

→ node Compare (279)

6 run 8 not run

1def _check_logical_tautology(self, node: nodes.Compare) -> None:
2        """Check if identifier is compared against itself.
3
4        :param node: Compare node
5        :Example:
6        val = 786
7        if val == val:  # [comparison-with-itself]
8            pass
9        """
10        left_operand = node.left
11        right_operand = node.ops[0][1]
12        operator = node.ops[0][0]
13        if isinstance(left_operand, nodes.Const) and isinstance(
14            right_operand, nodes.Const
15        ):
16            left_operand = left_operand.value
17            right_operand = right_operand.value
18        elif isinstance(left_operand, nodes.Name) and isinstance(
19            right_operand, nodes.Name
20        ):
21            left_operand = left_operand.name
22            right_operand = right_operand.name
23
24        if left_operand == right_operand:
25            suggestion = f"{left_operand} {operator} {right_operand}"
26            self.add_message("comparison-with-itself", node=node, args=(suggestion,))
            

Path 3: 164 calls (0.14)

→ node Compare (164)

7 run 7 not run

1def _check_logical_tautology(self, node: nodes.Compare) -> None:
2        """Check if identifier is compared against itself.
3
4        :param node: Compare node
5        :Example:
6        val = 786
7        if val == val:  # [comparison-with-itself]
8            pass
9        """
10        left_operand = node.left
11        right_operand = node.ops[0][1]
12        operator = node.ops[0][0]
13        if isinstance(left_operand, nodes.Const) and isinstance(
14            right_operand, nodes.Const
15        ):
16            left_operand = left_operand.value
17            right_operand = right_operand.value
18        elif isinstance(left_operand, nodes.Name) and isinstance(
19            right_operand, nodes.Name
20        ):
21            left_operand = left_operand.name
22            right_operand = right_operand.name
23
24        if left_operand == right_operand:
25            suggestion = f"{left_operand} {operator} {right_operand}"
26            self.add_message("comparison-with-itself", node=node, args=(suggestion,))
            

Path 4: 129 calls (0.11)

→ node Compare (129)

9 run 5 not run

1def _check_logical_tautology(self, node: nodes.Compare) -> None:
2        """Check if identifier is compared against itself.
3
4        :param node: Compare node
5        :Example:
6        val = 786
7        if val == val:  # [comparison-with-itself]
8            pass
9        """
10        left_operand = node.left
11        right_operand = node.ops[0][1]
12        operator = node.ops[0][0]
13        if isinstance(left_operand, nodes.Const) and isinstance(
14            right_operand, nodes.Const
15        ):
16            left_operand = left_operand.value
17            right_operand = right_operand.value
18        elif isinstance(left_operand, nodes.Name) and isinstance(
19            right_operand, nodes.Name
20        ):
21            left_operand = left_operand.name
22            right_operand = right_operand.name
23
24        if left_operand == right_operand:
25            suggestion = f"{left_operand} {operator} {right_operand}"
26            self.add_message("comparison-with-itself", node=node, args=(suggestion,))
            

Path 5: 37 calls (0.03)

→ node Compare (37)

8 run 6 not run

1def _check_logical_tautology(self, node: nodes.Compare) -> None:
2        """Check if identifier is compared against itself.
3
4        :param node: Compare node
5        :Example:
6        val = 786
7        if val == val:  # [comparison-with-itself]
8            pass
9        """
10        left_operand = node.left
11        right_operand = node.ops[0][1]
12        operator = node.ops[0][0]
13        if isinstance(left_operand, nodes.Const) and isinstance(
14            right_operand, nodes.Const
15        ):
16            left_operand = left_operand.value
17            right_operand = right_operand.value
18        elif isinstance(left_operand, nodes.Name) and isinstance(
19            right_operand, nodes.Name
20        ):
21            left_operand = left_operand.name
22            right_operand = right_operand.name
23
24        if left_operand == right_operand:
25            suggestion = f"{left_operand} {operator} {right_operand}"
26            self.add_message("comparison-with-itself", node=node, args=(suggestion,))
            

Path 6: 23 calls (0.02)

→ node Compare (23)

10 run 4 not run

1def _check_logical_tautology(self, node: nodes.Compare) -> None:
2        """Check if identifier is compared against itself.
3
4        :param node: Compare node
5        :Example:
6        val = 786
7        if val == val:  # [comparison-with-itself]
8            pass
9        """
10        left_operand = node.left
11        right_operand = node.ops[0][1]
12        operator = node.ops[0][0]
13        if isinstance(left_operand, nodes.Const) and isinstance(
14            right_operand, nodes.Const
15        ):
16            left_operand = left_operand.value
17            right_operand = right_operand.value
18        elif isinstance(left_operand, nodes.Name) and isinstance(
19            right_operand, nodes.Name
20        ):
21            left_operand = left_operand.name
22            right_operand = right_operand.name
23
24        if left_operand == right_operand:
25            suggestion = f"{left_operand} {operator} {right_operand}"
26            self.add_message("comparison-with-itself", node=node, args=(suggestion,))
            

Path 7: 7 calls (0.01)

→ node Compare (7)

11 run 3 not run

1def _check_logical_tautology(self, node: nodes.Compare) -> None:
2        """Check if identifier is compared against itself.
3
4        :param node: Compare node
5        :Example:
6        val = 786
7        if val == val:  # [comparison-with-itself]
8            pass
9        """
10        left_operand = node.left
11        right_operand = node.ops[0][1]
12        operator = node.ops[0][0]
13        if isinstance(left_operand, nodes.Const) and isinstance(
14            right_operand, nodes.Const
15        ):
16            left_operand = left_operand.value
17            right_operand = right_operand.value
18        elif isinstance(left_operand, nodes.Name) and isinstance(
19            right_operand, nodes.Name
20        ):
21            left_operand = left_operand.name
22            right_operand = right_operand.name
23
24        if left_operand == right_operand:
25            suggestion = f"{left_operand} {operator} {right_operand}"
26            self.add_message("comparison-with-itself", node=node, args=(suggestion,))