| # Copyright (c) 2003-2011 LOGILAB S.A. (Paris, FRANCE). |
| # http://www.logilab.fr/ -- mailto:contact@logilab.fr |
| # |
| # This program is free software; you can redistribute it and/or modify it under |
| # the terms of the GNU General Public License as published by the Free Software |
| # Foundation; either version 2 of the License, or (at your option) any later |
| # version. |
| # |
| # This program is distributed in the hope that it will be useful, but WITHOUT |
| # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License along with |
| # this program; if not, write to the Free Software Foundation, Inc., |
| # 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| """variables checkers for Python code |
| """ |
| |
| import sys |
| from copy import copy |
| |
| from logilab import astng |
| from logilab.astng import are_exclusive, builtin_lookup, ASTNGBuildingException |
| |
| from pylint.interfaces import IASTNGChecker |
| from pylint.checkers import BaseChecker |
| from pylint.checkers.utils import (PYMETHODS, is_ancestor_name, is_builtin, |
| is_defined_before, is_error, is_func_default, is_func_decorator, |
| assign_parent, check_messages, is_inside_except, clobber_in_except) |
| |
| |
| def in_for_else_branch(parent, stmt): |
| """Returns True if stmt in inside the else branch for a parent For stmt.""" |
| return (isinstance(parent, astng.For) and |
| any(else_stmt.parent_of(stmt) for else_stmt in parent.orelse)) |
| |
| def overridden_method(klass, name): |
| """get overridden method if any""" |
| try: |
| parent = klass.local_attr_ancestors(name).next() |
| except (StopIteration, KeyError): |
| return None |
| try: |
| meth_node = parent[name] |
| except KeyError: |
| # We have found an ancestor defining <name> but it's not in the local |
| # dictionary. This may happen with astng built from living objects. |
| return None |
| if isinstance(meth_node, astng.Function): |
| return meth_node |
| return None |
| |
| |
| MSGS = { |
| 'E0601': ('Using variable %r before assignment', |
| 'Used when a local variable is accessed before it\'s \ |
| assignment.'), |
| 'E0602': ('Undefined variable %r', |
| 'Used when an undefined variable is accessed.'), |
| 'E0611': ('No name %r in module %r', |
| 'Used when a name cannot be found in a module.'), |
| |
| 'W0601': ('Global variable %r undefined at the module level', |
| 'Used when a variable is defined through the "global" statement \ |
| but the variable is not defined in the module scope.'), |
| 'W0602': ('Using global for %r but no assignment is done', |
| 'Used when a variable is defined through the "global" statement \ |
| but no assignment to this variable is done.'), |
| 'W0603': ('Using the global statement', # W0121 |
| 'Used when you use the "global" statement to update a global \ |
| variable. PyLint just try to discourage this \ |
| usage. That doesn\'t mean you can not use it !'), |
| 'W0604': ('Using the global statement at the module level', # W0103 |
| 'Used when you use the "global" statement at the module level \ |
| since it has no effect'), |
| 'W0611': ('Unused import %s', |
| 'Used when an imported module or variable is not used.'), |
| 'W0612': ('Unused variable %r', |
| 'Used when a variable is defined but not used.'), |
| 'W0613': ('Unused argument %r', |
| 'Used when a function or method argument is not used.'), |
| 'W0614': ('Unused import %s from wildcard import', |
| 'Used when an imported module or variable is not used from a \ |
| \'from X import *\' style import.'), |
| |
| 'W0621': ('Redefining name %r from outer scope (line %s)', |
| 'Used when a variable\'s name hide a name defined in the outer \ |
| scope.'), |
| 'W0622': ('Redefining built-in %r', |
| 'Used when a variable or function override a built-in.'), |
| 'W0623': ('Redefining name %r from %s in exception handler', |
| 'Used when an exception handler assigns the exception \ |
| to an existing name'), |
| |
| 'W0631': ('Using possibly undefined loop variable %r', |
| 'Used when an loop variable (i.e. defined by a for loop or \ |
| a list comprehension or a generator expression) is used outside \ |
| the loop.'), |
| } |
| |
| class VariablesChecker(BaseChecker): |
| """checks for |
| * unused variables / imports |
| * undefined variables |
| * redefinition of variable from builtins or from an outer scope |
| * use of variable before assignment |
| """ |
| |
| __implements__ = IASTNGChecker |
| |
| name = 'variables' |
| msgs = MSGS |
| priority = -1 |
| options = ( |
| ("init-import", |
| {'default': 0, 'type' : 'yn', 'metavar' : '<y_or_n>', |
| 'help' : 'Tells whether we should check for unused import in \ |
| __init__ files.'}), |
| ("dummy-variables-rgx", |
| {'default': ('_|dummy'), |
| 'type' :'regexp', 'metavar' : '<regexp>', |
| 'help' : 'A regular expression matching the beginning of \ |
| the name of dummy variables (i.e. not used).'}), |
| ("additional-builtins", |
| {'default': (), 'type' : 'csv', |
| 'metavar' : '<comma separated list>', |
| 'help' : 'List of additional names supposed to be defined in \ |
| builtins. Remember that you should avoid to define new builtins when possible.' |
| }), |
| ) |
| def __init__(self, linter=None): |
| BaseChecker.__init__(self, linter) |
| self._to_consume = None |
| self._checking_mod_attr = None |
| self._vars = None |
| |
| def visit_module(self, node): |
| """visit module : update consumption analysis variable |
| checks globals doesn't overrides builtins |
| """ |
| self._to_consume = [(copy(node.locals), {}, 'module')] |
| self._vars = [] |
| for name, stmts in node.locals.items(): |
| if is_builtin(name) and not is_inside_except(stmts[0]): |
| # do not print Redefining builtin for additional builtins |
| self.add_message('W0622', args=name, node=stmts[0]) |
| |
| @check_messages('W0611', 'W0614') |
| def leave_module(self, node): |
| """leave module: check globals |
| """ |
| assert len(self._to_consume) == 1 |
| not_consumed = self._to_consume.pop()[0] |
| # don't check unused imports in __init__ files |
| if not self.config.init_import and node.package: |
| return |
| for name, stmts in not_consumed.items(): |
| stmt = stmts[0] |
| if isinstance(stmt, astng.Import): |
| self.add_message('W0611', args=name, node=stmt) |
| elif isinstance(stmt, astng.From) and stmt.modname != '__future__': |
| if stmt.names[0][0] == '*': |
| self.add_message('W0614', args=name, node=stmt) |
| else: |
| self.add_message('W0611', args=name, node=stmt) |
| del self._to_consume |
| del self._vars |
| |
| def visit_class(self, node): |
| """visit class: update consumption analysis variable |
| """ |
| self._to_consume.append((copy(node.locals), {}, 'class')) |
| |
| def leave_class(self, _): |
| """leave class: update consumption analysis variable |
| """ |
| # do not check for not used locals here (no sense) |
| self._to_consume.pop() |
| |
| def visit_lambda(self, node): |
| """visit lambda: update consumption analysis variable |
| """ |
| self._to_consume.append((copy(node.locals), {}, 'lambda')) |
| |
| def leave_lambda(self, _): |
| """leave lambda: update consumption analysis variable |
| """ |
| # do not check for not used locals here |
| self._to_consume.pop() |
| |
| def visit_genexpr(self, node): |
| """visit genexpr: update consumption analysis variable |
| """ |
| self._to_consume.append((copy(node.locals), {}, 'comprehension')) |
| |
| def leave_genexpr(self, _): |
| """leave genexpr: update consumption analysis variable |
| """ |
| # do not check for not used locals here |
| self._to_consume.pop() |
| |
| def visit_dictcomp(self, node): |
| """visit dictcomp: update consumption analysis variable |
| """ |
| self._to_consume.append((copy(node.locals), {}, 'comprehension')) |
| |
| def leave_dictcomp(self, _): |
| """leave dictcomp: update consumption analysis variable |
| """ |
| # do not check for not used locals here |
| self._to_consume.pop() |
| |
| def visit_setcomp(self, node): |
| """visit setcomp: update consumption analysis variable |
| """ |
| self._to_consume.append((copy(node.locals), {}, 'comprehension')) |
| |
| def leave_setcomp(self, _): |
| """leave setcomp: update consumption analysis variable |
| """ |
| # do not check for not used locals here |
| self._to_consume.pop() |
| |
| def visit_function(self, node): |
| """visit function: update consumption analysis variable and check locals |
| """ |
| self._to_consume.append((copy(node.locals), {}, 'function')) |
| self._vars.append({}) |
| if not set(('W0621', 'W0622')) & self.active_msgs: |
| return |
| globs = node.root().globals |
| for name, stmt in node.items(): |
| if is_inside_except(stmt): |
| continue |
| if name in globs and not isinstance(stmt, astng.Global): |
| line = globs[name][0].lineno |
| self.add_message('W0621', args=(name, line), node=stmt) |
| elif is_builtin(name): |
| # do not print Redefining builtin for additional builtins |
| self.add_message('W0622', args=name, node=stmt) |
| |
| def leave_function(self, node): |
| """leave function: check function's locals are consumed""" |
| not_consumed = self._to_consume.pop()[0] |
| self._vars.pop(0) |
| if not set(('W0612', 'W0613')) & self.active_msgs: |
| return |
| # don't check arguments of function which are only raising an exception |
| if is_error(node): |
| return |
| # don't check arguments of abstract methods or within an interface |
| is_method = node.is_method() |
| klass = node.parent.frame() |
| if is_method and (klass.type == 'interface' or node.is_abstract()): |
| return |
| authorized_rgx = self.config.dummy_variables_rgx |
| called_overridden = False |
| argnames = node.argnames() |
| for name, stmts in not_consumed.iteritems(): |
| # ignore some special names specified by user configuration |
| if authorized_rgx.match(name): |
| continue |
| # ignore names imported by the global statement |
| # FIXME: should only ignore them if it's assigned latter |
| stmt = stmts[0] |
| if isinstance(stmt, astng.Global): |
| continue |
| # care about functions with unknown argument (builtins) |
| if name in argnames: |
| if is_method: |
| # don't warn for the first argument of a (non static) method |
| if node.type != 'staticmethod' and name == argnames[0]: |
| continue |
| # don't warn for argument of an overridden method |
| if not called_overridden: |
| overridden = overridden_method(klass, node.name) |
| called_overridden = True |
| if overridden is not None and name in overridden.argnames(): |
| continue |
| if node.name in PYMETHODS and node.name not in ('__init__', '__new__'): |
| continue |
| # don't check callback arguments XXX should be configurable |
| if node.name.startswith('cb_') or node.name.endswith('_cb'): |
| continue |
| self.add_message('W0613', args=name, node=stmt) |
| else: |
| self.add_message('W0612', args=name, node=stmt) |
| |
| @check_messages('W0601', 'W0602', 'W0603', 'W0604', 'W0622') |
| def visit_global(self, node): |
| """check names imported exists in the global scope""" |
| frame = node.frame() |
| if isinstance(frame, astng.Module): |
| self.add_message('W0604', node=node) |
| return |
| module = frame.root() |
| default_message = True |
| for name in node.names: |
| try: |
| assign_nodes = module.getattr(name) |
| except astng.NotFoundError: |
| # unassigned global, skip |
| assign_nodes = [] |
| for anode in assign_nodes: |
| if anode.parent is None: |
| # node returned for builtin attribute such as __file__, |
| # __doc__, etc... |
| continue |
| if anode.frame() is frame: |
| # same scope level assignment |
| break |
| else: |
| # global but no assignment |
| self.add_message('W0602', args=name, node=node) |
| default_message = False |
| if not assign_nodes: |
| continue |
| for anode in assign_nodes: |
| if anode.parent is None: |
| self.add_message('W0622', args=name, node=node) |
| break |
| if anode.frame() is module: |
| # module level assignment |
| break |
| else: |
| # global undefined at the module scope |
| self.add_message('W0601', args=name, node=node) |
| default_message = False |
| if default_message: |
| self.add_message('W0603', node=node) |
| |
| def _loopvar_name(self, node, name): |
| # filter variables according to node's scope |
| # XXX used to filter parents but don't remember why, and removing this |
| # fixes a W0631 false positive reported by Paul Hachmann on 2008/12 on |
| # python-projects (added to func_use_for_or_listcomp_var test) |
| #astmts = [stmt for stmt in node.lookup(name)[1] |
| # if hasattr(stmt, 'ass_type')] and |
| # not stmt.statement().parent_of(node)] |
| if 'W0631' not in self.active_msgs: |
| return |
| astmts = [stmt for stmt in node.lookup(name)[1] |
| if hasattr(stmt, 'ass_type')] |
| # filter variables according their respective scope test is_statement |
| # and parent to avoid #74747. This is not a total fix, which would |
| # introduce a mechanism similar to special attribute lookup in |
| # modules. Also, in order to get correct inference in this case, the |
| # scope lookup rules would need to be changed to return the initial |
| # assignment (which does not exist in code per se) as well as any later |
| # modifications. |
| if not astmts or (astmts[0].is_statement or astmts[0].parent) \ |
| and astmts[0].statement().parent_of(node): |
| _astmts = [] |
| else: |
| _astmts = astmts[:1] |
| for i, stmt in enumerate(astmts[1:]): |
| if (astmts[i].statement().parent_of(stmt) |
| and not in_for_else_branch(astmts[i].statement(), stmt)): |
| continue |
| _astmts.append(stmt) |
| astmts = _astmts |
| if len(astmts) == 1: |
| ass = astmts[0].ass_type() |
| if isinstance(ass, (astng.For, astng.Comprehension, astng.GenExpr)) \ |
| and not ass.statement() is node.statement(): |
| self.add_message('W0631', args=name, node=node) |
| |
| def visit_excepthandler(self, node): |
| clobbering, args = clobber_in_except(node.name) |
| if clobbering: |
| self.add_message('W0623', args=args, node=node) |
| |
| def visit_assname(self, node): |
| if isinstance(node.ass_type(), astng.AugAssign): |
| self.visit_name(node) |
| |
| def visit_delname(self, node): |
| self.visit_name(node) |
| |
| def visit_name(self, node): |
| """check that a name is defined if the current scope and doesn't |
| redefine a built-in |
| """ |
| stmt = node.statement() |
| if stmt.fromlineno is None: |
| # name node from a astng built from live code, skip |
| assert not stmt.root().file.endswith('.py') |
| return |
| name = node.name |
| frame = stmt.scope() |
| # if the name node is used as a function default argument's value or as |
| # a decorator, then start from the parent frame of the function instead |
| # of the function frame - and thus open an inner class scope |
| if (is_func_default(node) or is_func_decorator(node) |
| or is_ancestor_name(frame, node)): |
| start_index = len(self._to_consume) - 2 |
| else: |
| start_index = len(self._to_consume) - 1 |
| # iterates through parent scopes, from the inner to the outer |
| base_scope_type = self._to_consume[start_index][-1] |
| for i in range(start_index, -1, -1): |
| to_consume, consumed, scope_type = self._to_consume[i] |
| # if the current scope is a class scope but it's not the inner |
| # scope, ignore it. This prevents to access this scope instead of |
| # the globals one in function members when there are some common |
| # names. The only exception is when the starting scope is a |
| # comprehension and its direct outer scope is a class |
| if scope_type == 'class' and i != start_index and not ( |
| base_scope_type == 'comprehension' and i == start_index-1): |
| # XXX find a way to handle class scope in a smoother way |
| continue |
| # the name has already been consumed, only check it's not a loop |
| # variable used outside the loop |
| if name in consumed: |
| self._loopvar_name(node, name) |
| break |
| # mark the name as consumed if it's defined in this scope |
| # (i.e. no KeyError is raised by "to_consume[name]") |
| try: |
| consumed[name] = to_consume[name] |
| except KeyError: |
| continue |
| # checks for use before assignment |
| defnode = assign_parent(to_consume[name][0]) |
| if defnode is not None: |
| defstmt = defnode.statement() |
| defframe = defstmt.frame() |
| maybee0601 = True |
| if not frame is defframe: |
| maybee0601 = False |
| elif defframe.parent is None: |
| # we are at the module level, check the name is not |
| # defined in builtins |
| if name in defframe.scope_attrs or builtin_lookup(name)[1]: |
| maybee0601 = False |
| else: |
| # we are in a local scope, check the name is not |
| # defined in global or builtin scope |
| if defframe.root().lookup(name)[1]: |
| maybee0601 = False |
| if (maybee0601 |
| and stmt.fromlineno <= defstmt.fromlineno |
| and not is_defined_before(node) |
| and not are_exclusive(stmt, defstmt, ('NameError', 'Exception', 'BaseException'))): |
| if defstmt is stmt and isinstance(node, (astng.DelName, |
| astng.AssName)): |
| self.add_message('E0602', args=name, node=node) |
| elif self._to_consume[-1][-1] != 'lambda': |
| # E0601 may *not* occurs in lambda scope |
| self.add_message('E0601', args=name, node=node) |
| if not isinstance(node, astng.AssName): # Aug AssName |
| del to_consume[name] |
| else: |
| del consumed[name] |
| # check it's not a loop variable used outside the loop |
| self._loopvar_name(node, name) |
| break |
| else: |
| # we have not found the name, if it isn't a builtin, that's an |
| # undefined name ! |
| if not (name in astng.Module.scope_attrs or is_builtin(name) |
| or name in self.config.additional_builtins): |
| self.add_message('E0602', args=name, node=node) |
| |
| @check_messages('E0611') |
| def visit_import(self, node): |
| """check modules attribute accesses""" |
| for name, _ in node.names: |
| parts = name.split('.') |
| try: |
| module = node.infer_name_module(parts[0]).next() |
| except astng.ResolveError: |
| continue |
| self._check_module_attrs(node, module, parts[1:]) |
| |
| @check_messages('E0611') |
| def visit_from(self, node): |
| """check modules attribute accesses""" |
| name_parts = node.modname.split('.') |
| level = getattr(node, 'level', None) |
| try: |
| module = node.root().import_module(name_parts[0], level=level) |
| except ASTNGBuildingException: |
| return |
| except Exception, exc: |
| print 'Unhandled exception in VariablesChecker:', exc |
| return |
| module = self._check_module_attrs(node, module, name_parts[1:]) |
| if not module: |
| return |
| for name, _ in node.names: |
| if name == '*': |
| continue |
| self._check_module_attrs(node, module, name.split('.')) |
| |
| def _check_module_attrs(self, node, module, module_names): |
| """check that module_names (list of string) are accessible through the |
| given module |
| if the latest access name corresponds to a module, return it |
| """ |
| assert isinstance(module, astng.Module), module |
| while module_names: |
| name = module_names.pop(0) |
| if name == '__dict__': |
| module = None |
| break |
| try: |
| module = module.getattr(name)[0].infer().next() |
| if module is astng.YES: |
| return None |
| except astng.NotFoundError: |
| self.add_message('E0611', args=(name, module.name), node=node) |
| return None |
| except astng.InferenceError: |
| return None |
| if module_names: |
| # FIXME: other message if name is not the latest part of |
| # module_names ? |
| modname = module and module.name or '__dict__' |
| self.add_message('E0611', node=node, |
| args=('.'.join(module_names), modname)) |
| return None |
| if isinstance(module, astng.Module): |
| return module |
| return None |
| |
| |
| class VariablesChecker3k(VariablesChecker): |
| '''Modified variables checker for 3k''' |
| # listcomp have now also their scope |
| |
| def visit_listcomp(self, node): |
| """visit dictcomp: update consumption analysis variable |
| """ |
| self._to_consume.append((copy(node.locals), {}, 'comprehension')) |
| |
| def leave_listcomp(self, _): |
| """leave dictcomp: update consumption analysis variable |
| """ |
| # do not check for not used locals here |
| self._to_consume.pop() |
| |
| if sys.version_info >= (3, 0): |
| VariablesChecker = VariablesChecker3k |
| |
| |
| def register(linter): |
| """required method to auto register this checker""" |
| linter.register_checker(VariablesChecker(linter)) |
