name : basic_checker.py # 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 """Basic checker for Python code.""" from __future__ import annotations import collections import itertools import sys from collections.abc import Iterator from typing import TYPE_CHECKING, cast import astroid from astroid import nodes, objects, util from pylint import utils as lint_utils from pylint.checkers import BaseChecker, utils from pylint.interfaces import HIGH, INFERENCE, Confidence from pylint.reporters.ureports import nodes as reporter_nodes from pylint.utils import LinterStats if TYPE_CHECKING: from pylint.lint.pylinter import PyLinter if sys.version_info >= (3, 8): from typing import Literal else: from typing_extensions import Literal class _BasicChecker(BaseChecker): """Permits separating multiple checks with the same checker name into classes/file. """ name = "basic" REVERSED_PROTOCOL_METHOD = "__reversed__" SEQUENCE_PROTOCOL_METHODS = ("__getitem__", "__len__") REVERSED_METHODS = (SEQUENCE_PROTOCOL_METHODS, (REVERSED_PROTOCOL_METHOD,)) # A mapping from qname -> symbol, to be used when generating messages # about dangerous default values as arguments DEFAULT_ARGUMENT_SYMBOLS = dict( zip( [".".join(["builtins", x]) for x in ("set", "dict", "list")], ["set()", "{}", "[]"], ), **{ x: f"{x}()" for x in ( "collections.deque", "collections.ChainMap", "collections.Counter", "collections.OrderedDict", "collections.defaultdict", "collections.UserDict", "collections.UserList", ) }, ) def report_by_type_stats( sect: reporter_nodes.Section, stats: LinterStats, old_stats: LinterStats | None, ) -> None: """Make a report of. * percentage of different types documented * percentage of different types with a bad name """ # percentage of different types documented and/or with a bad name nice_stats: dict[str, dict[str, str]] = {} for node_type in ("module", "class", "method", "function"): node_type = cast(Literal["function", "class", "method", "module"], node_type) total = stats.get_node_count(node_type) nice_stats[node_type] = {} if total != 0: undocumented_node = stats.get_undocumented(node_type) documented = total - undocumented_node percent = (documented * 100.0) / total nice_stats[node_type]["percent_documented"] = f"{percent:.2f}" badname_node = stats.get_bad_names(node_type) percent = (badname_node * 100.0) / total nice_stats[node_type]["percent_badname"] = f"{percent:.2f}" lines = ["type", "number", "old number", "difference", "%documented", "%badname"] for node_type in ("module", "class", "method", "function"): node_type = cast(Literal["function", "class", "method", "module"], node_type) new = stats.get_node_count(node_type) old = old_stats.get_node_count(node_type) if old_stats else None diff_str = lint_utils.diff_string(old, new) if old else None lines += [ node_type, str(new), str(old) if old else "NC", diff_str if diff_str else "NC", nice_stats[node_type].get("percent_documented", "0"), nice_stats[node_type].get("percent_badname", "0"), ] sect.append(reporter_nodes.Table(children=lines, cols=6, rheaders=1)) # pylint: disable-next = too-many-public-methods class BasicChecker(_BasicChecker): """Basic checker. Checks for : * doc strings * number of arguments, local variables, branches, returns and statements in functions, methods * required module attributes * dangerous default values as arguments * redefinition of function / method / class * uses of the global statement """ name = "basic" msgs = { "W0101": ( "Unreachable code", "unreachable", 'Used when there is some code behind a "return" or "raise" ' "statement, which will never be accessed.", ), "W0102": ( "Dangerous default value %s as argument", "dangerous-default-value", "Used when a mutable value as list or dictionary is detected in " "a default value for an argument.", ), "W0104": ( "Statement seems to have no effect", "pointless-statement", "Used when a statement doesn't have (or at least seems to) any effect.", ), "W0105": ( "String statement has no effect", "pointless-string-statement", "Used when a string is used as a statement (which of course " "has no effect). This is a particular case of W0104 with its " "own message so you can easily disable it if you're using " "those strings as documentation, instead of comments.", ), "W0106": ( 'Expression "%s" is assigned to nothing', "expression-not-assigned", "Used when an expression that is not a function call is assigned " "to nothing. Probably something else was intended.", ), "W0108": ( "Lambda may not be necessary", "unnecessary-lambda", "Used when the body of a lambda expression is a function call " "on the same argument list as the lambda itself; such lambda " "expressions are in all but a few cases replaceable with the " "function being called in the body of the lambda.", ), "W0109": ( "Duplicate key %r in dictionary", "duplicate-key", "Used when a dictionary expression binds the same key multiple times.", ), "W0122": ( "Use of exec", "exec-used", "Raised when the 'exec' statement is used. It's dangerous to use this " "function for a user input, and it's also slower than actual code in " "general. This doesn't mean you should never use it, but you should " "consider alternatives first and restrict the functions available.", ), "W0123": ( "Use of eval", "eval-used", 'Used when you use the "eval" function, to discourage its ' "usage. Consider using `ast.literal_eval` for safely evaluating " "strings containing Python expressions " "from untrusted sources.", ), "W0150": ( "%s statement in finally block may swallow exception", "lost-exception", "Used when a break or a return statement is found inside the " "finally clause of a try...finally block: the exceptions raised " "in the try clause will be silently swallowed instead of being " "re-raised.", ), "W0199": ( "Assert called on a populated tuple. Did you mean 'assert x,y'?", "assert-on-tuple", "A call of assert on a tuple will always evaluate to true if " "the tuple is not empty, and will always evaluate to false if " "it is.", ), "W0124": ( 'Following "as" with another context manager looks like a tuple.', "confusing-with-statement", "Emitted when a `with` statement component returns multiple values " "and uses name binding with `as` only for a part of those values, " "as in with ctx() as a, b. This can be misleading, since it's not " "clear if the context manager returns a tuple or if the node without " "a name binding is another context manager.", ), "W0125": ( "Using a conditional statement with a constant value", "using-constant-test", "Emitted when a conditional statement (If or ternary if) " "uses a constant value for its test. This might not be what " "the user intended to do.", ), "W0126": ( "Using a conditional statement with potentially wrong function or method call due to " "missing parentheses", "missing-parentheses-for-call-in-test", "Emitted when a conditional statement (If or ternary if) " "seems to wrongly call a function due to missing parentheses", ), "W0127": ( "Assigning the same variable %r to itself", "self-assigning-variable", "Emitted when we detect that a variable is assigned to itself", ), "W0128": ( "Redeclared variable %r in assignment", "redeclared-assigned-name", "Emitted when we detect that a variable was redeclared in the same assignment.", ), "E0111": ( "The first reversed() argument is not a sequence", "bad-reversed-sequence", "Used when the first argument to reversed() builtin " "isn't a sequence (does not implement __reversed__, " "nor __getitem__ and __len__", ), "E0119": ( "format function is not called on str", "misplaced-format-function", "Emitted when format function is not called on str object. " 'e.g doing print("value: {}").format(123) instead of ' 'print("value: {}".format(123)). This might not be what the user ' "intended to do.", ), "W0129": ( "Assert statement has a string literal as its first argument. The assert will %s fail.", "assert-on-string-literal", "Used when an assert statement has a string literal as its first argument, which will " "cause the assert to always pass.", ), "W0130": ( "Duplicate value %r in set", "duplicate-value", "This message is emitted when a set contains the same value two or more times.", ), "W0131": ( "Named expression used without context", "named-expr-without-context", "Emitted if named expression is used to do a regular assignment " "outside a context like if, for, while, or a comprehension.", ), "W0133": ( "Exception statement has no effect", "pointless-exception-statement", "Used when an exception is created without being assigned, raised or returned " "for subsequent use elsewhere.", ), } reports = (("RP0101", "Statistics by type", report_by_type_stats),) def __init__(self, linter: PyLinter) -> None: super().__init__(linter) self._tryfinallys: list[nodes.TryFinally] | None = None def open(self) -> None: """Initialize visit variables and statistics.""" py_version = self.linter.config.py_version self._py38_plus = py_version >= (3, 8) self._tryfinallys = [] self.linter.stats.reset_node_count() @utils.only_required_for_messages( "using-constant-test", "missing-parentheses-for-call-in-test" ) def visit_if(self, node: nodes.If) -> None: self._check_using_constant_test(node, node.test) @utils.only_required_for_messages( "using-constant-test", "missing-parentheses-for-call-in-test" ) def visit_ifexp(self, node: nodes.IfExp) -> None: self._check_using_constant_test(node, node.test) @utils.only_required_for_messages( "using-constant-test", "missing-parentheses-for-call-in-test" ) def visit_comprehension(self, node: nodes.Comprehension) -> None: if node.ifs: for if_test in node.ifs: self._check_using_constant_test(node, if_test) def _check_using_constant_test( self, node: nodes.If | nodes.IfExp | nodes.Comprehension, test: nodes.NodeNG | None, ) -> None: const_nodes = ( nodes.Module, nodes.GeneratorExp, nodes.Lambda, nodes.FunctionDef, nodes.ClassDef, astroid.bases.Generator, astroid.UnboundMethod, astroid.BoundMethod, nodes.Module, ) structs = (nodes.Dict, nodes.Tuple, nodes.Set, nodes.List) # These nodes are excepted, since they are not constant # values, requiring a computation to happen. except_nodes = ( nodes.Call, nodes.BinOp, nodes.BoolOp, nodes.UnaryOp, nodes.Subscript, ) inferred = None emit = isinstance(test, (nodes.Const,) + structs + const_nodes) maybe_generator_call = None if not isinstance(test, except_nodes): inferred = utils.safe_infer(test) if isinstance(inferred, util.UninferableBase) and isinstance( test, nodes.Name ): emit, maybe_generator_call = BasicChecker._name_holds_generator(test) # Emit if calling a function that only returns GeneratorExp (always tests True) elif isinstance(test, nodes.Call): maybe_generator_call = test if maybe_generator_call: inferred_call = utils.safe_infer(maybe_generator_call.func) if isinstance(inferred_call, nodes.FunctionDef): # Can't use all(x) or not any(not x) for this condition, because it # will return True for empty generators, which is not what we want. all_returns_were_generator = None for return_node in inferred_call._get_return_nodes_skip_functions(): if not isinstance(return_node.value, nodes.GeneratorExp): all_returns_were_generator = False break all_returns_were_generator = True if all_returns_were_generator: self.add_message( "using-constant-test", node=node, confidence=INFERENCE ) return if emit: self.add_message("using-constant-test", node=test, confidence=INFERENCE) elif isinstance(inferred, const_nodes): # If the constant node is a FunctionDef or Lambda then # it may be an illicit function call due to missing parentheses call_inferred = None try: # Just forcing the generator to infer all elements. # astroid.exceptions.InferenceError are false positives # see https://github.com/PyCQA/pylint/pull/8185 if isinstance(inferred, nodes.FunctionDef): call_inferred = list(inferred.infer_call_result()) elif isinstance(inferred, nodes.Lambda): call_inferred = list(inferred.infer_call_result(node)) except astroid.InferenceError: call_inferred = None if call_inferred: self.add_message( "missing-parentheses-for-call-in-test", node=test, confidence=INFERENCE, ) self.add_message("using-constant-test", node=test, confidence=INFERENCE) @staticmethod def _name_holds_generator(test: nodes.Name) -> tuple[bool, nodes.Call | None]: """Return whether `test` tests a name certain to hold a generator, or optionally a call that should be then tested to see if *it* returns only generators. """ assert isinstance(test, nodes.Name) emit = False maybe_generator_call = None lookup_result = test.frame(future=True).lookup(test.name) if not lookup_result: return emit, maybe_generator_call maybe_generator_assigned = ( isinstance(assign_name.parent.value, nodes.GeneratorExp) for assign_name in lookup_result[1] if isinstance(assign_name.parent, nodes.Assign) ) first_item = next(maybe_generator_assigned, None) if first_item is not None: # Emit if this variable is certain to hold a generator if all(itertools.chain((first_item,), maybe_generator_assigned)): emit = True # If this variable holds the result of a call, save it for next test elif ( len(lookup_result[1]) == 1 and isinstance(lookup_result[1][0].parent, nodes.Assign) and isinstance(lookup_result[1][0].parent.value, nodes.Call) ): maybe_generator_call = lookup_result[1][0].parent.value return emit, maybe_generator_call def visit_module(self, _: nodes.Module) -> None: """Check module name, docstring and required arguments.""" self.linter.stats.node_count["module"] += 1 def visit_classdef(self, _: nodes.ClassDef) -> None: """Check module name, docstring and redefinition increment branch counter. """ self.linter.stats.node_count["klass"] += 1 @utils.only_required_for_messages( "pointless-statement", "pointless-exception-statement", "pointless-string-statement", "expression-not-assigned", "named-expr-without-context", ) def visit_expr(self, node: nodes.Expr) -> None: """Check for various kind of statements without effect.""" expr = node.value if isinstance(expr, nodes.Const) and isinstance(expr.value, str): # treat string statement in a separated message # Handle PEP-257 attribute docstrings. # An attribute docstring is defined as being a string right after # an assignment at the module level, class level or __init__ level. scope = expr.scope() if isinstance(scope, (nodes.ClassDef, nodes.Module, nodes.FunctionDef)): if isinstance(scope, nodes.FunctionDef) and scope.name != "__init__": pass else: sibling = expr.previous_sibling() if ( sibling is not None and sibling.scope() is scope and isinstance(sibling, (nodes.Assign, nodes.AnnAssign)) ): return self.add_message("pointless-string-statement", node=node) return # Warn W0133 for exceptions that are used as statements if isinstance(expr, nodes.Call): name = "" if isinstance(expr.func, nodes.Name): name = expr.func.name elif isinstance(expr.func, nodes.Attribute): name = expr.func.attrname # Heuristic: only run inference for names that begin with an uppercase char # This reduces W0133's coverage, but retains acceptable runtime performance # For more details, see: https://github.com/PyCQA/pylint/issues/8073 inferred = utils.safe_infer(expr) if name[:1].isupper() else None if isinstance(inferred, objects.ExceptionInstance): self.add_message( "pointless-exception-statement", node=node, confidence=INFERENCE ) return # Ignore if this is : # * the unique child of a try/except body # * a yield statement # * an ellipsis (which can be used on Python 3 instead of pass) # warn W0106 if we have any underlying function call (we can't predict # side effects), else pointless-statement if ( isinstance(expr, (nodes.Yield, nodes.Await)) or (isinstance(node.parent, nodes.TryExcept) and node.parent.body == [node]) or (isinstance(expr, nodes.Const) and expr.value is Ellipsis) ): return if isinstance(expr, nodes.NamedExpr): self.add_message("named-expr-without-context", node=node, confidence=HIGH) elif any(expr.nodes_of_class(nodes.Call)): self.add_message( "expression-not-assigned", node=node, args=expr.as_string() ) else: self.add_message("pointless-statement", node=node) @staticmethod def _filter_vararg( node: nodes.Lambda, call_args: list[nodes.NodeNG] ) -> Iterator[nodes.NodeNG]: # Return the arguments for the given call which are # not passed as vararg. for arg in call_args: if isinstance(arg, nodes.Starred): if ( isinstance(arg.value, nodes.Name) and arg.value.name != node.args.vararg ): yield arg else: yield arg @staticmethod def _has_variadic_argument( args: list[nodes.Starred | nodes.Keyword], variadic_name: str ) -> bool: return not args or any( isinstance(a.value, nodes.Name) and a.value.name != variadic_name or not isinstance(a.value, nodes.Name) for a in args ) @utils.only_required_for_messages("unnecessary-lambda") # pylint: disable-next=too-many-return-statements def visit_lambda(self, node: nodes.Lambda) -> None: """Check whether the lambda is suspicious.""" # if the body of the lambda is a call expression with the same # argument list as the lambda itself, then the lambda is # possibly unnecessary and at least suspicious. if node.args.defaults: # If the arguments of the lambda include defaults, then a # judgment cannot be made because there is no way to check # that the defaults defined by the lambda are the same as # the defaults defined by the function called in the body # of the lambda. return call = node.body if not isinstance(call, nodes.Call): # The body of the lambda must be a function call expression # for the lambda to be unnecessary. return if isinstance(node.body.func, nodes.Attribute) and isinstance( node.body.func.expr, nodes.Call ): # Chained call, the intermediate call might # return something else (but we don't check that, yet). return call_site = astroid.arguments.CallSite.from_call(call) ordinary_args = list(node.args.args) new_call_args = list(self._filter_vararg(node, call.args)) if node.args.kwarg: if self._has_variadic_argument(call.kwargs, node.args.kwarg): return if node.args.vararg: if self._has_variadic_argument(call.starargs, node.args.vararg): return elif call.starargs: return if call.keywords: # Look for additional keyword arguments that are not part # of the lambda's signature lambda_kwargs = {keyword.name for keyword in node.args.defaults} if len(lambda_kwargs) != len(call_site.keyword_arguments): # Different lengths, so probably not identical return if set(call_site.keyword_arguments).difference(lambda_kwargs): return # The "ordinary" arguments must be in a correspondence such that: # ordinary_args[i].name == call.args[i].name. if len(ordinary_args) != len(new_call_args): return for arg, passed_arg in zip(ordinary_args, new_call_args): if not isinstance(passed_arg, nodes.Name): return if arg.name != passed_arg.name: return # The lambda is necessary if it uses its parameter in the function it is # calling in the lambda's body # e.g. lambda foo: (func1 if foo else func2)(foo) for name in call.func.nodes_of_class(nodes.Name): if name.lookup(name.name)[0] is node: return self.add_message("unnecessary-lambda", line=node.fromlineno, node=node) @utils.only_required_for_messages("dangerous-default-value") def visit_functiondef(self, node: nodes.FunctionDef) -> None: """Check function name, docstring, arguments, redefinition, variable names, max locals. """ if node.is_method(): self.linter.stats.node_count["method"] += 1 else: self.linter.stats.node_count["function"] += 1 self._check_dangerous_default(node) visit_asyncfunctiondef = visit_functiondef def _check_dangerous_default(self, node: nodes.FunctionDef) -> None: """Check for dangerous default values as arguments.""" def is_iterable(internal_node: nodes.NodeNG) -> bool: return isinstance(internal_node, (nodes.List, nodes.Set, nodes.Dict)) defaults = (node.args.defaults or []) + (node.args.kw_defaults or []) for default in defaults: if not default: continue try: value = next(default.infer()) except astroid.InferenceError: continue if ( isinstance(value, astroid.Instance) and value.qname() in DEFAULT_ARGUMENT_SYMBOLS ): if value is default: msg = DEFAULT_ARGUMENT_SYMBOLS[value.qname()] elif isinstance(value, astroid.Instance) or is_iterable(value): # We are here in the following situation(s): # * a dict/set/list/tuple call which wasn't inferred # to a syntax node ({}, () etc.). This can happen # when the arguments are invalid or unknown to # the inference. # * a variable from somewhere else, which turns out to be a list # or a dict. if is_iterable(default): msg = value.pytype() elif isinstance(default, nodes.Call): msg = f"{value.name}() ({value.qname()})" else: msg = f"{default.as_string()} ({value.qname()})" else: # this argument is a name msg = f"{default.as_string()} ({DEFAULT_ARGUMENT_SYMBOLS[value.qname()]})" self.add_message("dangerous-default-value", node=node, args=(msg,)) @utils.only_required_for_messages("unreachable", "lost-exception") def visit_return(self, node: nodes.Return) -> None: """Return node visitor. 1 - check if the node has a right sibling (if so, that's some unreachable code) 2 - check if the node is inside the 'finally' clause of a 'try...finally' block """ self._check_unreachable(node) # Is it inside final body of a try...finally block ? self._check_not_in_finally(node, "return", (nodes.FunctionDef,)) @utils.only_required_for_messages("unreachable") def visit_continue(self, node: nodes.Continue) -> None: """Check is the node has a right sibling (if so, that's some unreachable code). """ self._check_unreachable(node) @utils.only_required_for_messages("unreachable", "lost-exception") def visit_break(self, node: nodes.Break) -> None: """Break node visitor. 1 - check if the node has a right sibling (if so, that's some unreachable code) 2 - check if the node is inside the 'finally' clause of a 'try...finally' block """ # 1 - Is it right sibling ? self._check_unreachable(node) # 2 - Is it inside final body of a try...finally block ? self._check_not_in_finally(node, "break", (nodes.For, nodes.While)) @utils.only_required_for_messages("unreachable") def visit_raise(self, node: nodes.Raise) -> None: """Check if the node has a right sibling (if so, that's some unreachable code). """ self._check_unreachable(node) def _check_misplaced_format_function(self, call_node: nodes.Call) -> None: if not isinstance(call_node.func, nodes.Attribute): return if call_node.func.attrname != "format": return expr = utils.safe_infer(call_node.func.expr) if isinstance(expr, util.UninferableBase): return if not expr: # we are doubtful on inferred type of node, so here just check if format # was called on print() call_expr = call_node.func.expr if not isinstance(call_expr, nodes.Call): return if ( isinstance(call_expr.func, nodes.Name) and call_expr.func.name == "print" ): self.add_message("misplaced-format-function", node=call_node) @utils.only_required_for_messages( "eval-used", "exec-used", "bad-reversed-sequence", "misplaced-format-function", "unreachable", ) def visit_call(self, node: nodes.Call) -> None: """Visit a Call node.""" if utils.is_terminating_func(node): self._check_unreachable(node, confidence=INFERENCE) self._check_misplaced_format_function(node) if isinstance(node.func, nodes.Name): name = node.func.name # ignore the name if it's not a builtin (i.e. not defined in the # locals nor globals scope) if not (name in node.frame(future=True) or name in node.root()): if name == "exec": self.add_message("exec-used", node=node) elif name == "reversed": self._check_reversed(node) elif name == "eval": self.add_message("eval-used", node=node) @utils.only_required_for_messages("assert-on-tuple", "assert-on-string-literal") def visit_assert(self, node: nodes.Assert) -> None: """Check whether assert is used on a tuple or string literal.""" if isinstance(node.test, nodes.Tuple) and len(node.test.elts) > 0: self.add_message("assert-on-tuple", node=node, confidence=HIGH) if isinstance(node.test, nodes.Const) and isinstance(node.test.value, str): if node.test.value: when = "never" else: when = "always" self.add_message("assert-on-string-literal", node=node, args=(when,)) @utils.only_required_for_messages("duplicate-key") def visit_dict(self, node: nodes.Dict) -> None: """Check duplicate key in dictionary.""" keys = set() for k, _ in node.items: if isinstance(k, nodes.Const): key = k.value elif isinstance(k, nodes.Attribute): key = k.as_string() else: continue if key in keys: self.add_message("duplicate-key", node=node, args=key) keys.add(key) @utils.only_required_for_messages("duplicate-value") def visit_set(self, node: nodes.Set) -> None: """Check duplicate value in set.""" values = set() for v in node.elts: if isinstance(v, nodes.Const): value = v.value else: continue if value in values: self.add_message( "duplicate-value", node=node, args=value, confidence=HIGH ) values.add(value) def visit_tryfinally(self, node: nodes.TryFinally) -> None: """Update try...finally flag.""" assert self._tryfinallys is not None self._tryfinallys.append(node) def leave_tryfinally(self, _: nodes.TryFinally) -> None: """Update try...finally flag.""" assert self._tryfinallys is not None self._tryfinallys.pop() def _check_unreachable( self, node: nodes.Return | nodes.Continue | nodes.Break | nodes.Raise | nodes.Call, confidence: Confidence = HIGH, ) -> None: """Check unreachable code.""" unreachable_statement = node.next_sibling() if unreachable_statement is not None: if ( isinstance(node, nodes.Return) and isinstance(unreachable_statement, nodes.Expr) and isinstance(unreachable_statement.value, nodes.Yield) ): # Don't add 'unreachable' for empty generators. # Only add warning if 'yield' is followed by another node. unreachable_statement = unreachable_statement.next_sibling() if unreachable_statement is None: return self.add_message( "unreachable", node=unreachable_statement, confidence=confidence ) def _check_not_in_finally( self, node: nodes.Break | nodes.Return, node_name: str, breaker_classes: tuple[nodes.NodeNG, ...] = (), ) -> None: """Check that a node is not inside a 'finally' clause of a 'try...finally' statement. If we find a parent which type is in breaker_classes before a 'try...finally' block we skip the whole check. """ # if self._tryfinallys is empty, we're not an in try...finally block if not self._tryfinallys: return # the node could be a grand-grand...-child of the 'try...finally' _parent = node.parent _node = node while _parent and not isinstance(_parent, breaker_classes): if hasattr(_parent, "finalbody") and _node in _parent.finalbody: self.add_message("lost-exception", node=node, args=node_name) return _node = _parent _parent = _node.parent def _check_reversed(self, node: nodes.Call) -> None: """Check that the argument to `reversed` is a sequence.""" try: argument = utils.safe_infer(utils.get_argument_from_call(node, position=0)) except utils.NoSuchArgumentError: pass else: if isinstance(argument, util.UninferableBase): return if argument is None: # Nothing was inferred. # Try to see if we have iter(). if isinstance(node.args[0], nodes.Call): try: func = next(node.args[0].func.infer()) except astroid.InferenceError: return if getattr( func, "name", None ) == "iter" and utils.is_builtin_object(func): self.add_message("bad-reversed-sequence", node=node) return if isinstance(argument, (nodes.List, nodes.Tuple)): return # dicts are reversible, but only from Python 3.8 onward. Prior to # that, any class based on dict must explicitly provide a # __reversed__ method if not self._py38_plus and isinstance(argument, astroid.Instance): if any( ancestor.name == "dict" and utils.is_builtin_object(ancestor) for ancestor in itertools.chain( (argument._proxied,), argument._proxied.ancestors() ) ): try: argument.locals[REVERSED_PROTOCOL_METHOD] except KeyError: self.add_message("bad-reversed-sequence", node=node) return if hasattr(argument, "getattr"): # everything else is not a proper sequence for reversed() for methods in REVERSED_METHODS: for meth in methods: try: argument.getattr(meth) except astroid.NotFoundError: break else: break else: self.add_message("bad-reversed-sequence", node=node) else: self.add_message("bad-reversed-sequence", node=node) @utils.only_required_for_messages("confusing-with-statement") def visit_with(self, node: nodes.With) -> None: # a "with" statement with multiple managers corresponds # to one AST "With" node with multiple items pairs = node.items if pairs: for prev_pair, pair in zip(pairs, pairs[1:]): if isinstance(prev_pair[1], nodes.AssignName) and ( pair[1] is None and not isinstance(pair[0], nodes.Call) ): # Don't emit a message if the second is a function call # there's no way that can be mistaken for a name assignment. # If the line number doesn't match # we assume it's a nested "with". self.add_message("confusing-with-statement", node=node) def _check_self_assigning_variable(self, node: nodes.Assign) -> None: # Detect assigning to the same variable. scope = node.scope() scope_locals = scope.locals rhs_names = [] targets = node.targets if isinstance(targets[0], nodes.Tuple): if len(targets) != 1: # A complex assignment, so bail out early. return targets = targets[0].elts if len(targets) == 1: # Unpacking a variable into the same name. return if isinstance(node.value, nodes.Name): if len(targets) != 1: return rhs_names = [node.value] elif isinstance(node.value, nodes.Tuple): rhs_count = len(node.value.elts) if len(targets) != rhs_count or rhs_count == 1: return rhs_names = node.value.elts for target, lhs_name in zip(targets, rhs_names): if not isinstance(lhs_name, nodes.Name): continue if not isinstance(target, nodes.AssignName): continue # Check that the scope is different from a class level, which is usually # a pattern to expose module level attributes as class level ones. if isinstance(scope, nodes.ClassDef) and target.name in scope_locals: continue if target.name == lhs_name.name: self.add_message( "self-assigning-variable", args=(target.name,), node=target ) def _check_redeclared_assign_name(self, targets: list[nodes.NodeNG | None]) -> None: dummy_variables_rgx = self.linter.config.dummy_variables_rgx for target in targets: if not isinstance(target, nodes.Tuple): continue found_names = [] for element in target.elts: if isinstance(element, nodes.Tuple): self._check_redeclared_assign_name([element]) elif isinstance(element, nodes.AssignName) and element.name != "_": if dummy_variables_rgx and dummy_variables_rgx.match(element.name): return found_names.append(element.name) names = collections.Counter(found_names) for name, count in names.most_common(): if count > 1: self.add_message( "redeclared-assigned-name", args=(name,), node=target ) @utils.only_required_for_messages( "self-assigning-variable", "redeclared-assigned-name" ) def visit_assign(self, node: nodes.Assign) -> None: self._check_self_assigning_variable(node) self._check_redeclared_assign_name(node.targets) @utils.only_required_for_messages("redeclared-assigned-name") def visit_for(self, node: nodes.For) -> None: self._check_redeclared_assign_name([node.target])