diff options
Diffstat (limited to 'venv/Lib/site-packages/pylint/checkers/refactoring.py')
| -rw-r--r-- | venv/Lib/site-packages/pylint/checkers/refactoring.py | 1510 |
1 files changed, 0 insertions, 1510 deletions
diff --git a/venv/Lib/site-packages/pylint/checkers/refactoring.py b/venv/Lib/site-packages/pylint/checkers/refactoring.py deleted file mode 100644 index 2831343..0000000 --- a/venv/Lib/site-packages/pylint/checkers/refactoring.py +++ /dev/null @@ -1,1510 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright (c) 2016-2018 Claudiu Popa <pcmanticore@gmail.com> -# Copyright (c) 2016-2017 Łukasz Rogalski <rogalski.91@gmail.com> -# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com> -# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg> -# Copyright (c) 2017-2018 hippo91 <guillaume.peillex@gmail.com> -# Copyright (c) 2017 Ville Skyttä <ville.skytta@iki.fi> -# Copyright (c) 2017-2018 Bryce Guinta <bryce.paul.guinta@gmail.com> -# Copyright (c) 2017 Hugo <hugovk@users.noreply.github.com> -# Copyright (c) 2017 Łukasz Sznuk <ls@rdprojekt.pl> -# Copyright (c) 2017 Alex Hearn <alex.d.hearn@gmail.com> -# Copyright (c) 2017 Antonio Ossa <aaossa@uc.cl> -# Copyright (c) 2018 Konstantin Manna <Konstantin@Manna.uno> -# Copyright (c) 2018 Konstantin <Github@pheanex.de> -# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com> -# Copyright (c) 2018 Matej Marušák <marusak.matej@gmail.com> -# Copyright (c) 2018 Ville Skyttä <ville.skytta@upcloud.com> -# Copyright (c) 2018 Mr. Senko <atodorov@mrsenko.com> - -# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html -# For details: https://github.com/PyCQA/pylint/blob/master/COPYING - -"""Looks for code which can be refactored.""" -import builtins -import collections -import itertools -import tokenize -from functools import reduce - -import astroid -from astroid import decorators - -from pylint import checkers, interfaces -from pylint import utils as lint_utils -from pylint.checkers import utils - -KNOWN_INFINITE_ITERATORS = {"itertools.count"} -BUILTIN_EXIT_FUNCS = frozenset(("quit", "exit")) - - -def _if_statement_is_always_returning(if_node, returning_node_class): - for node in if_node.body: - if isinstance(node, returning_node_class): - return True - return False - - -def _is_len_call(node): - """Checks if node is len(SOMETHING).""" - return ( - isinstance(node, astroid.Call) - and isinstance(node.func, astroid.Name) - and node.func.name == "len" - ) - - -def _is_constant_zero(node): - return isinstance(node, astroid.Const) and node.value == 0 - - -def _node_is_test_condition(node): - """ Checks if node is an if, while, assert or if expression statement.""" - return isinstance(node, (astroid.If, astroid.While, astroid.Assert, astroid.IfExp)) - - -def _is_trailing_comma(tokens, index): - """Check if the given token is a trailing comma - - :param tokens: Sequence of modules tokens - :type tokens: list[tokenize.TokenInfo] - :param int index: Index of token under check in tokens - :returns: True if the token is a comma which trails an expression - :rtype: bool - """ - token = tokens[index] - if token.exact_type != tokenize.COMMA: - return False - # Must have remaining tokens on the same line such as NEWLINE - left_tokens = itertools.islice(tokens, index + 1, None) - same_line_remaining_tokens = list( - itertools.takewhile( - lambda other_token, _token=token: other_token.start[0] == _token.start[0], - left_tokens, - ) - ) - # Note: If the newline is tokenize.NEWLINE and not tokenize.NL - # then the newline denotes the end of expression - is_last_element = all( - other_token.type in (tokenize.NEWLINE, tokenize.COMMENT) - for other_token in same_line_remaining_tokens - ) - if not same_line_remaining_tokens or not is_last_element: - return False - - def get_curline_index_start(): - """Get the index denoting the start of the current line""" - for subindex, token in enumerate(reversed(tokens[:index])): - # See Lib/tokenize.py and Lib/token.py in cpython for more info - if token.type in (tokenize.NEWLINE, tokenize.NL): - return index - subindex - return 0 - - curline_start = get_curline_index_start() - expected_tokens = {"return", "yield"} - for prevtoken in tokens[curline_start:index]: - if "=" in prevtoken.string or prevtoken.string in expected_tokens: - return True - return False - - -class RefactoringChecker(checkers.BaseTokenChecker): - """Looks for code which can be refactored - - This checker also mixes the astroid and the token approaches - in order to create knowledge about whether an "else if" node - is a true "else if" node, or an "elif" node. - """ - - __implements__ = (interfaces.ITokenChecker, interfaces.IAstroidChecker) - - name = "refactoring" - - msgs = { - "R1701": ( - "Consider merging these isinstance calls to isinstance(%s, (%s))", - "consider-merging-isinstance", - "Used when multiple consecutive isinstance calls can be merged into one.", - ), - "R1706": ( - "Consider using ternary (%s)", - "consider-using-ternary", - "Used when one of known pre-python 2.5 ternary syntax is used.", - ), - "R1709": ( - "Boolean expression may be simplified to %s", - "simplify-boolean-expression", - "Emitted when redundant pre-python 2.5 ternary syntax is used.", - ), - "R1702": ( - "Too many nested blocks (%s/%s)", - "too-many-nested-blocks", - "Used when a function or a method has too many nested " - "blocks. This makes the code less understandable and " - "maintainable.", - {"old_names": [("R0101", "old-too-many-nested-blocks")]}, - ), - "R1703": ( - "The if statement can be replaced with %s", - "simplifiable-if-statement", - "Used when an if statement can be replaced with 'bool(test)'. ", - {"old_names": [("R0102", "old-simplifiable-if-statement")]}, - ), - "R1704": ( - "Redefining argument with the local name %r", - "redefined-argument-from-local", - "Used when a local name is redefining an argument, which might " - "suggest a potential error. This is taken in account only for " - "a handful of name binding operations, such as for iteration, " - "with statement assignment and exception handler assignment.", - ), - "R1705": ( - 'Unnecessary "%s" after "return"', - "no-else-return", - "Used in order to highlight an unnecessary block of " - "code following an if containing a return statement. " - "As such, it will warn when it encounters an else " - "following a chain of ifs, all of them containing a " - "return statement.", - ), - "R1707": ( - "Disallow trailing comma tuple", - "trailing-comma-tuple", - "In Python, a tuple is actually created by the comma symbol, " - "not by the parentheses. Unfortunately, one can actually create a " - "tuple by misplacing a trailing comma, which can lead to potential " - "weird bugs in your code. You should always use parentheses " - "explicitly for creating a tuple.", - ), - "R1708": ( - "Do not raise StopIteration in generator, use return statement instead", - "stop-iteration-return", - "According to PEP479, the raise of StopIteration to end the loop of " - "a generator may lead to hard to find bugs. This PEP specify that " - "raise StopIteration has to be replaced by a simple return statement", - ), - "R1710": ( - "Either all return statements in a function should return an expression, " - "or none of them should.", - "inconsistent-return-statements", - "According to PEP8, if any return statement returns an expression, " - "any return statements where no value is returned should explicitly " - "state this as return None, and an explicit return statement " - "should be present at the end of the function (if reachable)", - ), - "R1711": ( - "Useless return at end of function or method", - "useless-return", - 'Emitted when a single "return" or "return None" statement is found ' - "at the end of function or method definition. This statement can safely be " - "removed because Python will implicitly return None", - ), - "R1712": ( - "Consider using tuple unpacking for swapping variables", - "consider-swap-variables", - "You do not have to use a temporary variable in order to " - 'swap variables. Using "tuple unpacking" to directly swap ' - "variables makes the intention more clear.", - ), - "R1713": ( - "Consider using str.join(sequence) for concatenating " - "strings from an iterable", - "consider-using-join", - "Using str.join(sequence) is faster, uses less memory " - "and increases readability compared to for-loop iteration.", - ), - "R1714": ( - 'Consider merging these comparisons with "in" to %r', - "consider-using-in", - "To check if a variable is equal to one of many values," - 'combine the values into a tuple and check if the variable is contained "in" it ' - "instead of checking for equality against each of the values." - "This is faster and less verbose.", - ), - "R1715": ( - "Consider using dict.get for getting values from a dict " - "if a key is present or a default if not", - "consider-using-get", - "Using the builtin dict.get for getting a value from a dictionary " - "if a key is present or a default if not, is simpler and considered " - "more idiomatic, although sometimes a bit slower", - ), - "R1716": ( - "Simplify chained comparison between the operands", - "chained-comparison", - "This message is emitted when pylint encounters boolean operation like" - '"a < b and b < c", suggesting instead to refactor it to "a < b < c"', - ), - "R1717": ( - "Consider using a dictionary comprehension", - "consider-using-dict-comprehension", - "Emitted when we detect the creation of a dictionary " - "using the dict() callable and a transient list. " - "Although there is nothing syntactically wrong with this code, " - "it is hard to read and can be simplified to a dict comprehension." - "Also it is faster since you don't need to create another " - "transient list", - ), - "R1718": ( - "Consider using a set comprehension", - "consider-using-set-comprehension", - "Although there is nothing syntactically wrong with this code, " - "it is hard to read and can be simplified to a set comprehension." - "Also it is faster since you don't need to create another " - "transient list", - ), - "R1719": ( - "The if expression can be replaced with %s", - "simplifiable-if-expression", - "Used when an if expression can be replaced with 'bool(test)'. ", - ), - "R1720": ( - 'Unnecessary "%s" after "raise"', - "no-else-raise", - "Used in order to highlight an unnecessary block of " - "code following an if containing a raise statement. " - "As such, it will warn when it encounters an else " - "following a chain of ifs, all of them containing a " - "raise statement.", - ), - "R1721": ( - "Unnecessary use of a comprehension", - "unnecessary-comprehension", - "Instead of using an identitiy comprehension, " - "consider using the list, dict or set constructor. " - "It is faster and simpler.", - ), - "R1722": ( - "Consider using sys.exit()", - "consider-using-sys-exit", - "Instead of using exit() or quit(), consider using the sys.exit().", - ), - "R1723": ( - 'Unnecessary "%s" after "break"', - "no-else-break", - "Used in order to highlight an unnecessary block of " - "code following an if containing a break statement. " - "As such, it will warn when it encounters an else " - "following a chain of ifs, all of them containing a " - "break statement.", - ), - "R1724": ( - 'Unnecessary "%s" after "continue"', - "no-else-continue", - "Used in order to highlight an unnecessary block of " - "code following an if containing a continue statement. " - "As such, it will warn when it encounters an else " - "following a chain of ifs, all of them containing a " - "continue statement.", - ), - } - options = ( - ( - "max-nested-blocks", - { - "default": 5, - "type": "int", - "metavar": "<int>", - "help": "Maximum number of nested blocks for function / method body", - }, - ), - ( - "never-returning-functions", - { - "default": ("sys.exit",), - "type": "csv", - "help": "Complete name of functions that never returns. When checking " - "for inconsistent-return-statements if a never returning function is " - "called then it will be considered as an explicit return statement " - "and no message will be printed.", - }, - ), - ) - - priority = 0 - - def __init__(self, linter=None): - checkers.BaseTokenChecker.__init__(self, linter) - self._return_nodes = {} - self._init() - self._never_returning_functions = None - - def _init(self): - self._nested_blocks = [] - self._elifs = [] - self._nested_blocks_msg = None - self._reported_swap_nodes = set() - - def open(self): - # do this in open since config not fully initialized in __init__ - self._never_returning_functions = set(self.config.never_returning_functions) - - @decorators.cachedproperty - def _dummy_rgx(self): - return lint_utils.get_global_option(self, "dummy-variables-rgx", default=None) - - @staticmethod - def _is_bool_const(node): - return isinstance(node.value, astroid.Const) and isinstance( - node.value.value, bool - ) - - def _is_actual_elif(self, node): - """Check if the given node is an actual elif - - This is a problem we're having with the builtin ast module, - which splits `elif` branches into a separate if statement. - Unfortunately we need to know the exact type in certain - cases. - """ - if isinstance(node.parent, astroid.If): - orelse = node.parent.orelse - # current if node must directly follow an "else" - if orelse and orelse == [node]: - if (node.lineno, node.col_offset) in self._elifs: - return True - return False - - def _check_simplifiable_if(self, node): - """Check if the given if node can be simplified. - - The if statement can be reduced to a boolean expression - in some cases. For instance, if there are two branches - and both of them return a boolean value that depends on - the result of the statement's test, then this can be reduced - to `bool(test)` without losing any functionality. - """ - - if self._is_actual_elif(node): - # Not interested in if statements with multiple branches. - return - if len(node.orelse) != 1 or len(node.body) != 1: - return - - # Check if both branches can be reduced. - first_branch = node.body[0] - else_branch = node.orelse[0] - if isinstance(first_branch, astroid.Return): - if not isinstance(else_branch, astroid.Return): - return - first_branch_is_bool = self._is_bool_const(first_branch) - else_branch_is_bool = self._is_bool_const(else_branch) - reduced_to = "'return bool(test)'" - elif isinstance(first_branch, astroid.Assign): - if not isinstance(else_branch, astroid.Assign): - return - - # Check if we assign to the same value - first_branch_targets = [ - target.name - for target in first_branch.targets - if isinstance(target, astroid.AssignName) - ] - else_branch_targets = [ - target.name - for target in else_branch.targets - if isinstance(target, astroid.AssignName) - ] - if not first_branch_targets or not else_branch_targets: - return - if sorted(first_branch_targets) != sorted(else_branch_targets): - return - - first_branch_is_bool = self._is_bool_const(first_branch) - else_branch_is_bool = self._is_bool_const(else_branch) - reduced_to = "'var = bool(test)'" - else: - return - - if not first_branch_is_bool or not else_branch_is_bool: - return - if not first_branch.value.value: - # This is a case that can't be easily simplified and - # if it can be simplified, it will usually result in a - # code that's harder to understand and comprehend. - # Let's take for instance `arg and arg <= 3`. This could theoretically be - # reduced to `not arg or arg > 3`, but the net result is that now the - # condition is harder to understand, because it requires understanding of - # an extra clause: - # * first, there is the negation of truthness with `not arg` - # * the second clause is `arg > 3`, which occurs when arg has a - # a truth value, but it implies that `arg > 3` is equivalent - # with `arg and arg > 3`, which means that the user must - # think about this assumption when evaluating `arg > 3`. - # The original form is easier to grasp. - return - - self.add_message("simplifiable-if-statement", node=node, args=(reduced_to,)) - - def process_tokens(self, tokens): - # Process tokens and look for 'if' or 'elif' - for index, token in enumerate(tokens): - token_string = token[1] - if token_string == "elif": - # AST exists by the time process_tokens is called, so - # it's safe to assume tokens[index+1] - # exists. tokens[index+1][2] is the elif's position as - # reported by CPython and PyPy, - # tokens[index][2] is the actual position and also is - # reported by IronPython. - self._elifs.extend([tokens[index][2], tokens[index + 1][2]]) - elif _is_trailing_comma(tokens, index): - if self.linter.is_message_enabled("trailing-comma-tuple"): - self.add_message("trailing-comma-tuple", line=token.start[0]) - - def leave_module(self, _): - self._init() - - @utils.check_messages("too-many-nested-blocks") - def visit_tryexcept(self, node): - self._check_nested_blocks(node) - - visit_tryfinally = visit_tryexcept - visit_while = visit_tryexcept - - def _check_redefined_argument_from_local(self, name_node): - if self._dummy_rgx and self._dummy_rgx.match(name_node.name): - return - if not name_node.lineno: - # Unknown position, maybe it is a manually built AST? - return - - scope = name_node.scope() - if not isinstance(scope, astroid.FunctionDef): - return - - for defined_argument in scope.args.nodes_of_class( - astroid.AssignName, skip_klass=(astroid.Lambda,) - ): - if defined_argument.name == name_node.name: - self.add_message( - "redefined-argument-from-local", - node=name_node, - args=(name_node.name,), - ) - - @utils.check_messages("redefined-argument-from-local", "too-many-nested-blocks") - def visit_for(self, node): - self._check_nested_blocks(node) - - for name in node.target.nodes_of_class(astroid.AssignName): - self._check_redefined_argument_from_local(name) - - @utils.check_messages("redefined-argument-from-local") - def visit_excepthandler(self, node): - if node.name and isinstance(node.name, astroid.AssignName): - self._check_redefined_argument_from_local(node.name) - - @utils.check_messages("redefined-argument-from-local") - def visit_with(self, node): - for _, names in node.items: - if not names: - continue - for name in names.nodes_of_class(astroid.AssignName): - self._check_redefined_argument_from_local(name) - - def _check_superfluous_else(self, node, msg_id, returning_node_class): - if not node.orelse: - # Not interested in if statements without else. - return - - if self._is_actual_elif(node): - # Not interested in elif nodes; only if - return - - if _if_statement_is_always_returning(node, returning_node_class): - orelse = node.orelse[0] - followed_by_elif = (orelse.lineno, orelse.col_offset) in self._elifs - self.add_message( - msg_id, node=node, args="elif" if followed_by_elif else "else" - ) - - def _check_superfluous_else_return(self, node): - return self._check_superfluous_else( - node, msg_id="no-else-return", returning_node_class=astroid.Return - ) - - def _check_superfluous_else_raise(self, node): - return self._check_superfluous_else( - node, msg_id="no-else-raise", returning_node_class=astroid.Raise - ) - - def _check_superfluous_else_break(self, node): - return self._check_superfluous_else( - node, msg_id="no-else-break", returning_node_class=astroid.Break - ) - - def _check_superfluous_else_continue(self, node): - return self._check_superfluous_else( - node, msg_id="no-else-continue", returning_node_class=astroid.Continue - ) - - def _check_consider_get(self, node): - def type_and_name_are_equal(node_a, node_b): - for _type in [astroid.Name, astroid.AssignName]: - if all(isinstance(_node, _type) for _node in [node_a, node_b]): - return node_a.name == node_b.name - if all(isinstance(_node, astroid.Const) for _node in [node_a, node_b]): - return node_a.value == node_b.value - return False - - if_block_ok = ( - isinstance(node.test, astroid.Compare) - and len(node.body) == 1 - and isinstance(node.body[0], astroid.Assign) - and isinstance(node.body[0].value, astroid.Subscript) - and type_and_name_are_equal(node.body[0].value.value, node.test.ops[0][1]) - and isinstance(node.body[0].value.slice, astroid.Index) - and type_and_name_are_equal(node.body[0].value.slice.value, node.test.left) - and len(node.body[0].targets) == 1 - and isinstance(node.body[0].targets[0], astroid.AssignName) - and isinstance(utils.safe_infer(node.test.ops[0][1]), astroid.Dict) - ) - - if if_block_ok and not node.orelse: - self.add_message("consider-using-get", node=node) - elif ( - if_block_ok - and len(node.orelse) == 1 - and isinstance(node.orelse[0], astroid.Assign) - and type_and_name_are_equal( - node.orelse[0].targets[0], node.body[0].targets[0] - ) - and len(node.orelse[0].targets) == 1 - ): - self.add_message("consider-using-get", node=node) - - @utils.check_messages( - "too-many-nested-blocks", - "simplifiable-if-statement", - "no-else-return", - "no-else-raise", - "no-else-break", - "no-else-continue", - "consider-using-get", - ) - def visit_if(self, node): - self._check_simplifiable_if(node) - self._check_nested_blocks(node) - self._check_superfluous_else_return(node) - self._check_superfluous_else_raise(node) - self._check_superfluous_else_break(node) - self._check_superfluous_else_continue(node) - self._check_consider_get(node) - - @utils.check_messages("simplifiable-if-expression") - def visit_ifexp(self, node): - self._check_simplifiable_ifexp(node) - - def _check_simplifiable_ifexp(self, node): - if not isinstance(node.body, astroid.Const) or not isinstance( - node.orelse, astroid.Const - ): - return - - if not isinstance(node.body.value, bool) or not isinstance( - node.orelse.value, bool - ): - return - - if isinstance(node.test, astroid.Compare): - test_reduced_to = "test" - else: - test_reduced_to = "bool(test)" - - if (node.body.value, node.orelse.value) == (True, False): - reduced_to = "'{}'".format(test_reduced_to) - elif (node.body.value, node.orelse.value) == (False, True): - reduced_to = "'not test'" - else: - return - - self.add_message("simplifiable-if-expression", node=node, args=(reduced_to,)) - - @utils.check_messages( - "too-many-nested-blocks", "inconsistent-return-statements", "useless-return" - ) - def leave_functiondef(self, node): - # check left-over nested blocks stack - self._emit_nested_blocks_message_if_needed(self._nested_blocks) - # new scope = reinitialize the stack of nested blocks - self._nested_blocks = [] - # check consistent return statements - self._check_consistent_returns(node) - # check for single return or return None at the end - self._check_return_at_the_end(node) - self._return_nodes[node.name] = [] - - @utils.check_messages("stop-iteration-return") - def visit_raise(self, node): - self._check_stop_iteration_inside_generator(node) - - def _check_stop_iteration_inside_generator(self, node): - """Check if an exception of type StopIteration is raised inside a generator""" - frame = node.frame() - if not isinstance(frame, astroid.FunctionDef) or not frame.is_generator(): - return - if utils.node_ignores_exception(node, StopIteration): - return - if not node.exc: - return - exc = utils.safe_infer(node.exc) - if exc is None or exc is astroid.Uninferable: - return - if self._check_exception_inherit_from_stopiteration(exc): - self.add_message("stop-iteration-return", node=node) - - @staticmethod - def _check_exception_inherit_from_stopiteration(exc): - """Return True if the exception node in argument inherit from StopIteration""" - stopiteration_qname = "{}.StopIteration".format(utils.EXCEPTIONS_MODULE) - return any(_class.qname() == stopiteration_qname for _class in exc.mro()) - - def _check_consider_using_comprehension_constructor(self, node): - if ( - isinstance(node.func, astroid.Name) - and node.args - and isinstance(node.args[0], astroid.ListComp) - ): - if node.func.name == "dict" and not isinstance( - node.args[0].elt, astroid.Call - ): - message_name = "consider-using-dict-comprehension" - self.add_message(message_name, node=node) - elif node.func.name == "set": - message_name = "consider-using-set-comprehension" - self.add_message(message_name, node=node) - - @utils.check_messages( - "stop-iteration-return", - "consider-using-dict-comprehension", - "consider-using-set-comprehension", - "consider-using-sys-exit", - ) - def visit_call(self, node): - self._check_raising_stopiteration_in_generator_next_call(node) - self._check_consider_using_comprehension_constructor(node) - self._check_quit_exit_call(node) - - @staticmethod - def _has_exit_in_scope(scope): - exit_func = scope.locals.get("exit") - return bool( - exit_func and isinstance(exit_func[0], (astroid.ImportFrom, astroid.Import)) - ) - - def _check_quit_exit_call(self, node): - - if isinstance(node.func, astroid.Name) and node.func.name in BUILTIN_EXIT_FUNCS: - # If we have `exit` imported from `sys` in the current or global scope, exempt this instance. - local_scope = node.scope() - if self._has_exit_in_scope(local_scope) or self._has_exit_in_scope( - node.root() - ): - return - self.add_message("consider-using-sys-exit", node=node) - - def _check_raising_stopiteration_in_generator_next_call(self, node): - """Check if a StopIteration exception is raised by the call to next function - - If the next value has a default value, then do not add message. - - :param node: Check to see if this Call node is a next function - :type node: :class:`astroid.node_classes.Call` - """ - - def _looks_like_infinite_iterator(param): - inferred = utils.safe_infer(param) - if inferred: - return inferred.qname() in KNOWN_INFINITE_ITERATORS - return False - - if isinstance(node.func, astroid.Attribute): - # A next() method, which is now what we want. - return - - inferred = utils.safe_infer(node.func) - if getattr(inferred, "name", "") == "next": - frame = node.frame() - # The next builtin can only have up to two - # positional arguments and no keyword arguments - has_sentinel_value = len(node.args) > 1 - if ( - isinstance(frame, astroid.FunctionDef) - and frame.is_generator() - and not has_sentinel_value - and not utils.node_ignores_exception(node, StopIteration) - and not _looks_like_infinite_iterator(node.args[0]) - ): - self.add_message("stop-iteration-return", node=node) - - def _check_nested_blocks(self, node): - """Update and check the number of nested blocks - """ - # only check block levels inside functions or methods - if not isinstance(node.scope(), astroid.FunctionDef): - return - # messages are triggered on leaving the nested block. Here we save the - # stack in case the current node isn't nested in the previous one - nested_blocks = self._nested_blocks[:] - if node.parent == node.scope(): - self._nested_blocks = [node] - else: - # go through ancestors from the most nested to the less - for ancestor_node in reversed(self._nested_blocks): - if ancestor_node == node.parent: - break - self._nested_blocks.pop() - # if the node is an elif, this should not be another nesting level - if isinstance(node, astroid.If) and self._is_actual_elif(node): - if self._nested_blocks: - self._nested_blocks.pop() - self._nested_blocks.append(node) - - # send message only once per group of nested blocks - if len(nested_blocks) > len(self._nested_blocks): - self._emit_nested_blocks_message_if_needed(nested_blocks) - - def _emit_nested_blocks_message_if_needed(self, nested_blocks): - if len(nested_blocks) > self.config.max_nested_blocks: - self.add_message( - "too-many-nested-blocks", - node=nested_blocks[0], - args=(len(nested_blocks), self.config.max_nested_blocks), - ) - - @staticmethod - def _duplicated_isinstance_types(node): - """Get the duplicated types from the underlying isinstance calls. - - :param astroid.BoolOp node: Node which should contain a bunch of isinstance calls. - :returns: Dictionary of the comparison objects from the isinstance calls, - to duplicate values from consecutive calls. - :rtype: dict - """ - duplicated_objects = set() - all_types = collections.defaultdict(set) - - for call in node.values: - if not isinstance(call, astroid.Call) or len(call.args) != 2: - continue - - inferred = utils.safe_infer(call.func) - if not inferred or not utils.is_builtin_object(inferred): - continue - - if inferred.name != "isinstance": - continue - - isinstance_object = call.args[0].as_string() - isinstance_types = call.args[1] - - if isinstance_object in all_types: - duplicated_objects.add(isinstance_object) - - if isinstance(isinstance_types, astroid.Tuple): - elems = [ - class_type.as_string() for class_type in isinstance_types.itered() - ] - else: - elems = [isinstance_types.as_string()] - all_types[isinstance_object].update(elems) - - # Remove all keys which not duplicated - return { - key: value for key, value in all_types.items() if key in duplicated_objects - } - - def _check_consider_merging_isinstance(self, node): - """Check isinstance calls which can be merged together.""" - if node.op != "or": - return - - first_args = self._duplicated_isinstance_types(node) - for duplicated_name, class_names in first_args.items(): - names = sorted(name for name in class_names) - self.add_message( - "consider-merging-isinstance", - node=node, - args=(duplicated_name, ", ".join(names)), - ) - - def _check_consider_using_in(self, node): - allowed_ops = {"or": "==", "and": "!="} - - if node.op not in allowed_ops or len(node.values) < 2: - return - - for value in node.values: - if ( - not isinstance(value, astroid.Compare) - or len(value.ops) != 1 - or value.ops[0][0] not in allowed_ops[node.op] - ): - return - for comparable in value.left, value.ops[0][1]: - if isinstance(comparable, astroid.Call): - return - - # Gather variables and values from comparisons - variables, values = [], [] - for value in node.values: - variable_set = set() - for comparable in value.left, value.ops[0][1]: - if isinstance(comparable, astroid.Name): - variable_set.add(comparable.as_string()) - values.append(comparable.as_string()) - variables.append(variable_set) - - # Look for (common-)variables that occur in all comparisons - common_variables = reduce(lambda a, b: a.intersection(b), variables) - - if not common_variables: - return - - # Gather information for the suggestion - common_variable = sorted(list(common_variables))[0] - comprehension = "in" if node.op == "or" else "not in" - values = list(collections.OrderedDict.fromkeys(values)) - values.remove(common_variable) - values_string = ", ".join(values) if len(values) != 1 else values[0] + "," - suggestion = "%s %s (%s)" % (common_variable, comprehension, values_string) - - self.add_message("consider-using-in", node=node, args=(suggestion,)) - - def _check_chained_comparison(self, node): - """Check if there is any chained comparison in the expression. - - Add a refactoring message if a boolOp contains comparison like a < b and b < c, - which can be chained as a < b < c. - - Care is taken to avoid simplifying a < b < c and b < d. - """ - if node.op != "and" or len(node.values) < 2: - return - - def _find_lower_upper_bounds(comparison_node, uses): - left_operand = comparison_node.left - for operator, right_operand in comparison_node.ops: - for operand in (left_operand, right_operand): - value = None - if isinstance(operand, astroid.Name): - value = operand.name - elif isinstance(operand, astroid.Const): - value = operand.value - - if value is None: - continue - - if operator in ("<", "<="): - if operand is left_operand: - uses[value]["lower_bound"].add(comparison_node) - elif operand is right_operand: - uses[value]["upper_bound"].add(comparison_node) - elif operator in (">", ">="): - if operand is left_operand: - uses[value]["upper_bound"].add(comparison_node) - elif operand is right_operand: - uses[value]["lower_bound"].add(comparison_node) - left_operand = right_operand - - uses = collections.defaultdict( - lambda: {"lower_bound": set(), "upper_bound": set()} - ) - for comparison_node in node.values: - if isinstance(comparison_node, astroid.Compare): - _find_lower_upper_bounds(comparison_node, uses) - - for _, bounds in uses.items(): - num_shared = len(bounds["lower_bound"].intersection(bounds["upper_bound"])) - num_lower_bounds = len(bounds["lower_bound"]) - num_upper_bounds = len(bounds["upper_bound"]) - if num_shared < num_lower_bounds and num_shared < num_upper_bounds: - self.add_message("chained-comparison", node=node) - break - - @utils.check_messages( - "consider-merging-isinstance", "consider-using-in", "chained-comparison" - ) - def visit_boolop(self, node): - self._check_consider_merging_isinstance(node) - self._check_consider_using_in(node) - self._check_chained_comparison(node) - - @staticmethod - def _is_simple_assignment(node): - return ( - isinstance(node, astroid.Assign) - and len(node.targets) == 1 - and isinstance(node.targets[0], astroid.node_classes.AssignName) - and isinstance(node.value, astroid.node_classes.Name) - ) - - def _check_swap_variables(self, node): - if not node.next_sibling() or not node.next_sibling().next_sibling(): - return - assignments = [node, node.next_sibling(), node.next_sibling().next_sibling()] - if not all(self._is_simple_assignment(node) for node in assignments): - return - if any(node in self._reported_swap_nodes for node in assignments): - return - left = [node.targets[0].name for node in assignments] - right = [node.value.name for node in assignments] - if left[0] == right[-1] and left[1:] == right[:-1]: - self._reported_swap_nodes.update(assignments) - message = "consider-swap-variables" - self.add_message(message, node=node) - - @utils.check_messages( - "simplify-boolean-expression", - "consider-using-ternary", - "consider-swap-variables", - ) - def visit_assign(self, node): - self._check_swap_variables(node) - if self._is_and_or_ternary(node.value): - cond, truth_value, false_value = self._and_or_ternary_arguments(node.value) - else: - return - - if all( - isinstance(value, astroid.Compare) for value in (truth_value, false_value) - ): - return - - inferred_truth_value = utils.safe_infer(truth_value) - if inferred_truth_value in (None, astroid.Uninferable): - truth_boolean_value = True - else: - truth_boolean_value = truth_value.bool_value() - - if truth_boolean_value is False: - message = "simplify-boolean-expression" - suggestion = false_value.as_string() - else: - message = "consider-using-ternary" - suggestion = "{truth} if {cond} else {false}".format( - truth=truth_value.as_string(), - cond=cond.as_string(), - false=false_value.as_string(), - ) - self.add_message(message, node=node, args=(suggestion,)) - - visit_return = visit_assign - - def _check_consider_using_join(self, aug_assign): - """ - We start with the augmented assignment and work our way upwards. - Names of variables for nodes if match successful: - result = '' # assign - for number in ['1', '2', '3'] # for_loop - result += number # aug_assign - """ - for_loop = aug_assign.parent - if not isinstance(for_loop, astroid.For) or len(for_loop.body) > 1: - return - assign = for_loop.previous_sibling() - if not isinstance(assign, astroid.Assign): - return - result_assign_names = { - target.name - for target in assign.targets - if isinstance(target, astroid.AssignName) - } - - is_concat_loop = ( - aug_assign.op == "+=" - and isinstance(aug_assign.target, astroid.AssignName) - and len(for_loop.body) == 1 - and aug_assign.target.name in result_assign_names - and isinstance(assign.value, astroid.Const) - and isinstance(assign.value.value, str) - and isinstance(aug_assign.value, astroid.Name) - and aug_assign.value.name == for_loop.target.name - ) - if is_concat_loop: - self.add_message("consider-using-join", node=aug_assign) - - @utils.check_messages("consider-using-join") - def visit_augassign(self, node): - self._check_consider_using_join(node) - - @utils.check_messages("unnecessary-comprehension") - def visit_comprehension(self, node): - self._check_unnecessary_comprehension(node) - - def _check_unnecessary_comprehension(self, node): - if ( - isinstance(node.parent, astroid.GeneratorExp) - or len(node.ifs) != 0 - or len(node.parent.generators) != 1 - or node.is_async - ): - return - - if ( - isinstance(node.parent, astroid.DictComp) - and isinstance(node.parent.key, astroid.Name) - and isinstance(node.parent.value, astroid.Name) - and isinstance(node.target, astroid.Tuple) - and all(isinstance(elt, astroid.AssignName) for elt in node.target.elts) - ): - expr_list = [node.parent.key.name, node.parent.value.name] - target_list = [elt.name for elt in node.target.elts] - - elif isinstance(node.parent, (astroid.ListComp, astroid.SetComp)): - expr = node.parent.elt - if isinstance(expr, astroid.Name): - expr_list = expr.name - elif isinstance(expr, astroid.Tuple): - if any(not isinstance(elt, astroid.Name) for elt in expr.elts): - return - expr_list = [elt.name for elt in expr.elts] - else: - expr_list = [] - target = node.parent.generators[0].target - target_list = ( - target.name - if isinstance(target, astroid.AssignName) - else ( - [ - elt.name - for elt in target.elts - if isinstance(elt, astroid.AssignName) - ] - if isinstance(target, astroid.Tuple) - else [] - ) - ) - else: - return - if expr_list == target_list != []: - self.add_message("unnecessary-comprehension", node=node) - - @staticmethod - def _is_and_or_ternary(node): - """ - Returns true if node is 'condition and true_value or false_value' form. - - All of: condition, true_value and false_value should not be a complex boolean expression - """ - return ( - isinstance(node, astroid.BoolOp) - and node.op == "or" - and len(node.values) == 2 - and isinstance(node.values[0], astroid.BoolOp) - and not isinstance(node.values[1], astroid.BoolOp) - and node.values[0].op == "and" - and not isinstance(node.values[0].values[1], astroid.BoolOp) - and len(node.values[0].values) == 2 - ) - - @staticmethod - def _and_or_ternary_arguments(node): - false_value = node.values[1] - condition, true_value = node.values[0].values - return condition, true_value, false_value - - def visit_functiondef(self, node): - self._return_nodes[node.name] = list( - node.nodes_of_class(astroid.Return, skip_klass=astroid.FunctionDef) - ) - - def _check_consistent_returns(self, node): - """Check that all return statements inside a function are consistent. - - Return statements are consistent if: - - all returns are explicit and if there is no implicit return; - - all returns are empty and if there is, possibly, an implicit return. - - Args: - node (astroid.FunctionDef): the function holding the return statements. - - """ - # explicit return statements are those with a not None value - explicit_returns = [ - _node for _node in self._return_nodes[node.name] if _node.value is not None - ] - if not explicit_returns: - return - if len(explicit_returns) == len( - self._return_nodes[node.name] - ) and self._is_node_return_ended(node): - return - self.add_message("inconsistent-return-statements", node=node) - - def _is_node_return_ended(self, node): - """Check if the node ends with an explicit return statement. - - Args: - node (astroid.NodeNG): node to be checked. - - Returns: - bool: True if the node ends with an explicit statement, False otherwise. - - """ - # Recursion base case - if isinstance(node, astroid.Return): - return True - if isinstance(node, astroid.Call): - try: - funcdef_node = node.func.inferred()[0] - if self._is_function_def_never_returning(funcdef_node): - return True - except astroid.InferenceError: - pass - # Avoid the check inside while loop as we don't know - # if they will be completed - if isinstance(node, astroid.While): - return True - if isinstance(node, astroid.Raise): - # a Raise statement doesn't need to end with a return statement - # but if the exception raised is handled, then the handler has to - # ends with a return statement - if not node.exc: - # Ignore bare raises - return True - if not utils.is_node_inside_try_except(node): - # If the raise statement is not inside a try/except statement - # then the exception is raised and cannot be caught. No need - # to infer it. - return True - exc = utils.safe_infer(node.exc) - if exc is None or exc is astroid.Uninferable: - return False - exc_name = exc.pytype().split(".")[-1] - handlers = utils.get_exception_handlers(node, exc_name) - handlers = list(handlers) if handlers is not None else [] - if handlers: - # among all the handlers handling the exception at least one - # must end with a return statement - return any( - self._is_node_return_ended(_handler) for _handler in handlers - ) - # if no handlers handle the exception then it's ok - return True - if isinstance(node, astroid.If): - # if statement is returning if there are exactly two return statements in its - # children : one for the body part, the other for the orelse part - # Do not check if inner function definition are return ended. - is_orelse_returning = any( - self._is_node_return_ended(_ore) - for _ore in node.orelse - if not isinstance(_ore, astroid.FunctionDef) - ) - is_if_returning = any( - self._is_node_return_ended(_ifn) - for _ifn in node.body - if not isinstance(_ifn, astroid.FunctionDef) - ) - return is_if_returning and is_orelse_returning - # recurses on the children of the node except for those which are except handler - # because one cannot be sure that the handler will really be used - return any( - self._is_node_return_ended(_child) - for _child in node.get_children() - if not isinstance(_child, astroid.ExceptHandler) - ) - - def _is_function_def_never_returning(self, node): - """Return True if the function never returns. False otherwise. - - Args: - node (astroid.FunctionDef): function definition node to be analyzed. - - Returns: - bool: True if the function never returns, False otherwise. - """ - try: - return node.qname() in self._never_returning_functions - except TypeError: - return False - - def _check_return_at_the_end(self, node): - """Check for presence of a *single* return statement at the end of a - function. "return" or "return None" are useless because None is the - default return type if they are missing. - - NOTE: produces a message only if there is a single return statement - in the function body. Otherwise _check_consistent_returns() is called! - Per its implementation and PEP8 we can have a "return None" at the end - of the function body if there are other return statements before that! - """ - if len(self._return_nodes[node.name]) > 1: - return - if len(node.body) <= 1: - return - - last = node.body[-1] - if isinstance(last, astroid.Return): - # e.g. "return" - if last.value is None: - self.add_message("useless-return", node=node) - # return None" - elif isinstance(last.value, astroid.Const) and (last.value.value is None): - self.add_message("useless-return", node=node) - - -class RecommandationChecker(checkers.BaseChecker): - __implements__ = (interfaces.IAstroidChecker,) - name = "refactoring" - msgs = { - "C0200": ( - "Consider using enumerate instead of iterating with range and len", - "consider-using-enumerate", - "Emitted when code that iterates with range and len is " - "encountered. Such code can be simplified by using the " - "enumerate builtin.", - ), - "C0201": ( - "Consider iterating the dictionary directly instead of calling .keys()", - "consider-iterating-dictionary", - "Emitted when the keys of a dictionary are iterated through the .keys() " - "method. It is enough to just iterate through the dictionary itself, as " - 'in "for key in dictionary".', - ), - } - - @staticmethod - def _is_builtin(node, function): - inferred = utils.safe_infer(node) - if not inferred: - return False - return utils.is_builtin_object(inferred) and inferred.name == function - - @utils.check_messages("consider-iterating-dictionary") - def visit_call(self, node): - if not isinstance(node.func, astroid.Attribute): - return - if node.func.attrname != "keys": - return - if not isinstance(node.parent, (astroid.For, astroid.Comprehension)): - return - - inferred = utils.safe_infer(node.func) - if not isinstance(inferred, astroid.BoundMethod) or not isinstance( - inferred.bound, astroid.Dict - ): - return - - if isinstance(node.parent, (astroid.For, astroid.Comprehension)): - self.add_message("consider-iterating-dictionary", node=node) - - @utils.check_messages("consider-using-enumerate") - def visit_for(self, node): - """Emit a convention whenever range and len are used for indexing.""" - # Verify that we have a `range([start], len(...), [stop])` call and - # that the object which is iterated is used as a subscript in the - # body of the for. - - # Is it a proper range call? - if not isinstance(node.iter, astroid.Call): - return - if not self._is_builtin(node.iter.func, "range"): - return - if len(node.iter.args) == 2 and not _is_constant_zero(node.iter.args[0]): - return - if len(node.iter.args) > 2: - return - - # Is it a proper len call? - if not isinstance(node.iter.args[-1], astroid.Call): - return - second_func = node.iter.args[-1].func - if not self._is_builtin(second_func, "len"): - return - len_args = node.iter.args[-1].args - if not len_args or len(len_args) != 1: - return - iterating_object = len_args[0] - if not isinstance(iterating_object, astroid.Name): - return - # If we're defining __iter__ on self, enumerate won't work - scope = node.scope() - if iterating_object.name == "self" and scope.name == "__iter__": - return - - # Verify that the body of the for loop uses a subscript - # with the object that was iterated. This uses some heuristics - # in order to make sure that the same object is used in the - # for body. - for child in node.body: - for subscript in child.nodes_of_class(astroid.Subscript): - if not isinstance(subscript.value, astroid.Name): - continue - if not isinstance(subscript.slice, astroid.Index): - continue - if not isinstance(subscript.slice.value, astroid.Name): - continue - if subscript.slice.value.name != node.target.name: - continue - if iterating_object.name != subscript.value.name: - continue - if subscript.value.scope() != node.scope(): - # Ignore this subscript if it's not in the same - # scope. This means that in the body of the for - # loop, another scope was created, where the same - # name for the iterating object was used. - continue - self.add_message("consider-using-enumerate", node=node) - return - - -class NotChecker(checkers.BaseChecker): - """checks for too many not in comparison expressions - - - "not not" should trigger a warning - - "not" followed by a comparison should trigger a warning - """ - - __implements__ = (interfaces.IAstroidChecker,) - msgs = { - "C0113": ( - 'Consider changing "%s" to "%s"', - "unneeded-not", - "Used when a boolean expression contains an unneeded negation.", - ) - } - name = "refactoring" - reverse_op = { - "<": ">=", - "<=": ">", - ">": "<=", - ">=": "<", - "==": "!=", - "!=": "==", - "in": "not in", - "is": "is not", - } - # sets are not ordered, so for example "not set(LEFT_VALS) <= set(RIGHT_VALS)" is - # not equivalent to "set(LEFT_VALS) > set(RIGHT_VALS)" - skipped_nodes = (astroid.Set,) - # 'builtins' py3, '__builtin__' py2 - skipped_classnames = [ - "%s.%s" % (builtins.__name__, qname) for qname in ("set", "frozenset") - ] - - @utils.check_messages("unneeded-not") - def visit_unaryop(self, node): - if node.op != "not": - return - operand = node.operand - - if isinstance(operand, astroid.UnaryOp) and operand.op == "not": - self.add_message( - "unneeded-not", - node=node, - args=(node.as_string(), operand.operand.as_string()), - ) - elif isinstance(operand, astroid.Compare): - left = operand.left - # ignore multiple comparisons - if len(operand.ops) > 1: - return - operator, right = operand.ops[0] - if operator not in self.reverse_op: - return - # Ignore __ne__ as function of __eq__ - frame = node.frame() - if frame.name == "__ne__" and operator == "==": - return - for _type in (utils.node_type(left), utils.node_type(right)): - if not _type: - return - if isinstance(_type, self.skipped_nodes): - return - if ( - isinstance(_type, astroid.Instance) - and _type.qname() in self.skipped_classnames - ): - return - suggestion = "%s %s %s" % ( - left.as_string(), - self.reverse_op[operator], - right.as_string(), - ) - self.add_message( - "unneeded-not", node=node, args=(node.as_string(), suggestion) - ) - - -class LenChecker(checkers.BaseChecker): - """Checks for incorrect usage of len() inside conditions. - Pep8 states: - For sequences, (strings, lists, tuples), use the fact that empty sequences are false. - - Yes: if not seq: - if seq: - - No: if len(seq): - if not len(seq): - - Problems detected: - * if len(sequence): - * if not len(sequence): - * elif len(sequence): - * elif not len(sequence): - * while len(sequence): - * while not len(sequence): - * assert len(sequence): - * assert not len(sequence): - """ - - __implements__ = (interfaces.IAstroidChecker,) - - # configuration section name - name = "refactoring" - msgs = { - "C1801": ( - "Do not use `len(SEQUENCE)` without comparison to determine if a sequence is empty", - "len-as-condition", - "Used when Pylint detects that len(sequence) is being used " - "without explicit comparison inside a condition to determine if a sequence is empty. " - "Instead of coercing the length to a boolean, either " - "rely on the fact that empty sequences are false or " - "compare the length against a scalar.", - ) - } - - priority = -2 - options = () - - @utils.check_messages("len-as-condition") - def visit_call(self, node): - # a len(S) call is used inside a test condition - # could be if, while, assert or if expression statement - # e.g. `if len(S):` - if _is_len_call(node): - # the len() call could also be nested together with other - # boolean operations, e.g. `if z or len(x):` - parent = node.parent - while isinstance(parent, astroid.BoolOp): - parent = parent.parent - - # we're finally out of any nested boolean operations so check if - # this len() call is part of a test condition - if not _node_is_test_condition(parent): - return - if not (node is parent.test or parent.test.parent_of(node)): - return - self.add_message("len-as-condition", node=node) - - @utils.check_messages("len-as-condition") - def visit_unaryop(self, node): - """`not len(S)` must become `not S` regardless if the parent block - is a test condition or something else (boolean expression) - e.g. `if not len(S):`""" - if ( - isinstance(node, astroid.UnaryOp) - and node.op == "not" - and _is_len_call(node.operand) - ): - self.add_message("len-as-condition", node=node) - - -def register(linter): - """Required method to auto register this checker.""" - linter.register_checker(RefactoringChecker(linter)) - linter.register_checker(NotChecker(linter)) - linter.register_checker(RecommandationChecker(linter)) - linter.register_checker(LenChecker(linter)) |