diff options
Diffstat (limited to 'pylint/checkers/base/comparison_checker.py')
| -rw-r--r-- | pylint/checkers/base/comparison_checker.py | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/pylint/checkers/base/comparison_checker.py b/pylint/checkers/base/comparison_checker.py new file mode 100644 index 000000000..1db50761b --- /dev/null +++ b/pylint/checkers/base/comparison_checker.py @@ -0,0 +1,295 @@ +# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html +# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE +# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt + +"""Comparison checker from the basic checker.""" + +import astroid +from astroid import nodes + +from pylint.checkers import utils +from pylint.checkers.base.basic_checker import _BasicChecker + +LITERAL_NODE_TYPES = (nodes.Const, nodes.Dict, nodes.List, nodes.Set) +COMPARISON_OPERATORS = frozenset(("==", "!=", "<", ">", "<=", ">=")) +TYPECHECK_COMPARISON_OPERATORS = frozenset(("is", "is not", "==", "!=")) +TYPE_QNAME = "builtins.type" + + +def _is_one_arg_pos_call(call): + """Is this a call with exactly 1 positional argument ?""" + return isinstance(call, nodes.Call) and len(call.args) == 1 and not call.keywords + + +class ComparisonChecker(_BasicChecker): + """Checks for comparisons. + + - singleton comparison: 'expr == True', 'expr == False' and 'expr == None' + - yoda condition: 'const "comp" right' where comp can be '==', '!=', '<', + '<=', '>' or '>=', and right can be a variable, an attribute, a method or + a function + """ + + msgs = { + "C0121": ( + "Comparison %s should be %s", + "singleton-comparison", + "Used when an expression is compared to singleton " + "values like True, False or None.", + ), + "C0123": ( + "Use isinstance() rather than type() for a typecheck.", + "unidiomatic-typecheck", + "The idiomatic way to perform an explicit typecheck in " + "Python is to use isinstance(x, Y) rather than " + "type(x) == Y, type(x) is Y. Though there are unusual " + "situations where these give different results.", + {"old_names": [("W0154", "old-unidiomatic-typecheck")]}, + ), + "R0123": ( + "Comparison to literal", + "literal-comparison", + "Used when comparing an object to a literal, which is usually " + "what you do not want to do, since you can compare to a different " + "literal than what was expected altogether.", + ), + "R0124": ( + "Redundant comparison - %s", + "comparison-with-itself", + "Used when something is compared against itself.", + ), + "W0143": ( + "Comparing against a callable, did you omit the parenthesis?", + "comparison-with-callable", + "This message is emitted when pylint detects that a comparison with a " + "callable was made, which might suggest that some parenthesis were omitted, " + "resulting in potential unwanted behaviour.", + ), + "W0177": ( + "Comparison %s should be %s", + "nan-comparison", + "Used when an expression is compared to NaN" + "values like numpy.NaN and float('nan')", + ), + } + + def _check_singleton_comparison( + self, left_value, right_value, root_node, checking_for_absence: bool = False + ): + """Check if == or != is being used to compare a singleton value.""" + singleton_values = (True, False, None) + + def _is_singleton_const(node) -> bool: + return isinstance(node, nodes.Const) and any( + node.value is value for value in singleton_values + ) + + if _is_singleton_const(left_value): + singleton, other_value = left_value.value, right_value + elif _is_singleton_const(right_value): + singleton, other_value = right_value.value, left_value + else: + return + + singleton_comparison_example = {False: "'{} is {}'", True: "'{} is not {}'"} + + # True/False singletons have a special-cased message in case the user is + # mistakenly using == or != to check for truthiness + if singleton in {True, False}: + suggestion_template = ( + "{} if checking for the singleton value {}, or {} if testing for {}" + ) + truthiness_example = {False: "not {}", True: "{}"} + truthiness_phrase = {True: "truthiness", False: "falsiness"} + + # Looks for comparisons like x == True or x != False + checking_truthiness = singleton is not checking_for_absence + + suggestion = suggestion_template.format( + singleton_comparison_example[checking_for_absence].format( + left_value.as_string(), right_value.as_string() + ), + singleton, + ( + "'bool({})'" + if not utils.is_test_condition(root_node) and checking_truthiness + else "'{}'" + ).format( + truthiness_example[checking_truthiness].format( + other_value.as_string() + ) + ), + truthiness_phrase[checking_truthiness], + ) + else: + suggestion = singleton_comparison_example[checking_for_absence].format( + left_value.as_string(), right_value.as_string() + ) + self.add_message( + "singleton-comparison", + node=root_node, + args=(f"'{root_node.as_string()}'", suggestion), + ) + + def _check_nan_comparison( + self, left_value, right_value, root_node, checking_for_absence: bool = False + ): + def _is_float_nan(node): + try: + if isinstance(node, nodes.Call) and len(node.args) == 1: + if ( + node.args[0].value.lower() == "nan" + and node.inferred()[0].pytype() == "builtins.float" + ): + return True + return False + except AttributeError: + return False + + def _is_numpy_nan(node): + if isinstance(node, nodes.Attribute) and node.attrname == "NaN": + if isinstance(node.expr, nodes.Name): + return node.expr.name in {"numpy", "nmp", "np"} + return False + + def _is_nan(node) -> bool: + return _is_float_nan(node) or _is_numpy_nan(node) + + nan_left = _is_nan(left_value) + if not nan_left and not _is_nan(right_value): + return + + absence_text = "" + if checking_for_absence: + absence_text = "not " + if nan_left: + suggestion = f"'{absence_text}math.isnan({right_value.as_string()})'" + else: + suggestion = f"'{absence_text}math.isnan({left_value.as_string()})'" + self.add_message( + "nan-comparison", + node=root_node, + args=(f"'{root_node.as_string()}'", suggestion), + ) + + def _check_literal_comparison(self, literal, node: nodes.Compare): + """Check if we compare to a literal, which is usually what we do not want to do.""" + is_other_literal = isinstance(literal, (nodes.List, nodes.Dict, nodes.Set)) + is_const = False + if isinstance(literal, nodes.Const): + if isinstance(literal.value, bool) or literal.value is None: + # Not interested in these values. + return + is_const = isinstance(literal.value, (bytes, str, int, float)) + + if is_const or is_other_literal: + self.add_message("literal-comparison", node=node) + + def _check_logical_tautology(self, node: nodes.Compare): + """Check if identifier is compared against itself. + + :param node: Compare node + :Example: + val = 786 + if val == val: # [comparison-with-itself] + pass + """ + left_operand = node.left + right_operand = node.ops[0][1] + operator = node.ops[0][0] + if isinstance(left_operand, nodes.Const) and isinstance( + right_operand, nodes.Const + ): + left_operand = left_operand.value + right_operand = right_operand.value + elif isinstance(left_operand, nodes.Name) and isinstance( + right_operand, nodes.Name + ): + left_operand = left_operand.name + right_operand = right_operand.name + + if left_operand == right_operand: + suggestion = f"{left_operand} {operator} {right_operand}" + self.add_message("comparison-with-itself", node=node, args=(suggestion,)) + + def _check_callable_comparison(self, node): + operator = node.ops[0][0] + if operator not in COMPARISON_OPERATORS: + return + + bare_callables = (nodes.FunctionDef, astroid.BoundMethod) + left_operand, right_operand = node.left, node.ops[0][1] + # this message should be emitted only when there is comparison of bare callable + # with non bare callable. + number_of_bare_callables = 0 + for operand in left_operand, right_operand: + inferred = utils.safe_infer(operand) + # Ignore callables that raise, as well as typing constants + # implemented as functions (that raise via their decorator) + if ( + isinstance(inferred, bare_callables) + and "typing._SpecialForm" not in inferred.decoratornames() + and not any(isinstance(x, nodes.Raise) for x in inferred.body) + ): + number_of_bare_callables += 1 + if number_of_bare_callables == 1: + self.add_message("comparison-with-callable", node=node) + + @utils.check_messages( + "singleton-comparison", + "unidiomatic-typecheck", + "literal-comparison", + "comparison-with-itself", + "comparison-with-callable", + ) + def visit_compare(self, node: nodes.Compare) -> None: + self._check_callable_comparison(node) + self._check_logical_tautology(node) + self._check_unidiomatic_typecheck(node) + # NOTE: this checker only works with binary comparisons like 'x == 42' + # but not 'x == y == 42' + if len(node.ops) != 1: + return + + left = node.left + operator, right = node.ops[0] + + if operator in {"==", "!="}: + self._check_singleton_comparison( + left, right, node, checking_for_absence=operator == "!=" + ) + + if operator in {"==", "!=", "is", "is not"}: + self._check_nan_comparison( + left, right, node, checking_for_absence=operator in {"!=", "is not"} + ) + if operator in {"is", "is not"}: + self._check_literal_comparison(right, node) + + def _check_unidiomatic_typecheck(self, node): + operator, right = node.ops[0] + if operator in TYPECHECK_COMPARISON_OPERATORS: + left = node.left + if _is_one_arg_pos_call(left): + self._check_type_x_is_y(node, left, operator, right) + + def _check_type_x_is_y(self, node, left, operator, right): + """Check for expressions like type(x) == Y.""" + left_func = utils.safe_infer(left.func) + if not ( + isinstance(left_func, nodes.ClassDef) and left_func.qname() == TYPE_QNAME + ): + return + + if operator in {"is", "is not"} and _is_one_arg_pos_call(right): + right_func = utils.safe_infer(right.func) + if ( + isinstance(right_func, nodes.ClassDef) + and right_func.qname() == TYPE_QNAME + ): + # type(x) == type(a) + right_arg = utils.safe_infer(right.args[0]) + if not isinstance(right_arg, LITERAL_NODE_TYPES): + # not e.g. type(x) == type([]) + return + self.add_message("unidiomatic-typecheck", node=node) |