| # Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html |
| # For details: https://github.com/pylint-dev/pylint/blob/main/LICENSE |
| # Copyright (c) https://github.com/pylint-dev/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 |
| from pylint.interfaces import HIGH |
| |
| 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: nodes.NodeNG) -> bool: |
| """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": ( |
| "In '%s', use '%s' when comparing constant literals not '%s' ('%s')", |
| "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.", |
| ), |
| "R0133": ( |
| "Comparison between constants: '%s %s %s' has a constant value", |
| "comparison-of-constants", |
| "When two literals are compared with each other the result is a constant. " |
| "Using the constant directly is both easier to read and more performant. " |
| "Initializing 'True' and 'False' this way is not required since Python 2.3.", |
| ), |
| "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: nodes.NodeNG, |
| right_value: nodes.NodeNG, |
| root_node: nodes.Compare, |
| checking_for_absence: bool = False, |
| ) -> None: |
| """Check if == or != is being used to compare a singleton value.""" |
| if utils.is_singleton_const(left_value): |
| singleton, other_value = left_value.value, right_value |
| elif utils.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: nodes.NodeNG, |
| right_value: nodes.NodeNG, |
| root_node: nodes.Compare, |
| checking_for_absence: bool = False, |
| ) -> None: |
| def _is_float_nan(node: nodes.NodeNG) -> bool: |
| 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: nodes.NodeNG) -> bool: |
| 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: nodes.NodeNG) -> 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: nodes.NodeNG, node: nodes.Compare |
| ) -> None: |
| """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: |
| incorrect_node_str = node.as_string() |
| if "is not" in incorrect_node_str: |
| equal_or_not_equal = "!=" |
| is_or_is_not = "is not" |
| else: |
| equal_or_not_equal = "==" |
| is_or_is_not = "is" |
| fixed_node_str = incorrect_node_str.replace( |
| is_or_is_not, equal_or_not_equal |
| ) |
| self.add_message( |
| "literal-comparison", |
| args=( |
| incorrect_node_str, |
| equal_or_not_equal, |
| is_or_is_not, |
| fixed_node_str, |
| ), |
| node=node, |
| confidence=HIGH, |
| ) |
| |
| def _check_logical_tautology(self, node: nodes.Compare) -> None: |
| """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_constants_comparison(self, node: nodes.Compare) -> None: |
| """When two constants are being compared it is always a logical tautology.""" |
| left_operand = node.left |
| if not isinstance(left_operand, nodes.Const): |
| return |
| |
| right_operand = node.ops[0][1] |
| if not isinstance(right_operand, nodes.Const): |
| return |
| |
| operator = node.ops[0][0] |
| self.add_message( |
| "comparison-of-constants", |
| node=node, |
| args=(left_operand.value, operator, right_operand.value), |
| confidence=HIGH, |
| ) |
| |
| def _check_callable_comparison(self, node: nodes.Compare) -> None: |
| 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.only_required_for_messages( |
| "singleton-comparison", |
| "unidiomatic-typecheck", |
| "literal-comparison", |
| "comparison-with-itself", |
| "comparison-of-constants", |
| "comparison-with-callable", |
| "nan-comparison", |
| ) |
| def visit_compare(self, node: nodes.Compare) -> None: |
| self._check_callable_comparison(node) |
| self._check_logical_tautology(node) |
| self._check_unidiomatic_typecheck(node) |
| self._check_constants_comparison(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: nodes.Compare) -> None: |
| 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: nodes.Compare, |
| left: nodes.NodeNG, |
| operator: str, |
| right: nodes.NodeNG, |
| ) -> None: |
| """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) |
