eric: comparison UtilitiesPython2/py2flakes/checker.py

-:7d766369823d
+:acae49c8d343
 # -*- coding: utf-8 -*-
 # Copyright (c) 2011 - 2012 Detlev Offenbach <detlev@die-offenbachs.de>
 #
-# Original (c) 2005-2008 Divmod, Inc.
+# Original (c) 2005-2010 Divmod, Inc.
 #
 # This module is based on pyflakes for Python2 but was heavily hacked to
 # work within eric5
 import __builtin__
 import os.path
-import compiler
+import _ast
-from compiler import ast
 from py2flakes import messages
+# utility function to iterate over an AST node's children, adapted
+# from Python 2.6's standard ast module
+try:
+import ast
+iter_child_nodes = ast.iter_child_nodes
+except (ImportError, AttributeError):
+def iter_child_nodes(node, astcls=_ast.AST):
+"""
+Yield all direct child nodes of *node*, that is, all fields that are nodes
+and all items of fields that are lists of nodes.
+"""
+for name in node._fields:
+field = getattr(node, name, None)
+if isinstance(field, astcls):
+yield field
+elif isinstance(field, list):
+for item in field:
+yield item
 class Binding(object):
 """
 Represents the binding of a value to a name.
 def names(self):
 """
 Return a list of the names referenced by this binding.
 """
 names = []
-if isinstance(self.source, ast.List):
+if isinstance(self.source, _ast.List):
-for node in self.source.nodes:
+for node in self.source.elts:
-if isinstance(node, ast.Const):
+if isinstance(node, _ast.Str):
-names.append(node.value)
+names.append(node.s)
 return names
 class Scope(dict):
 """
 Class defining the scope base class.
 """
 importStarred = False       # set to True when import * is found
 def __repr__(self):
-return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), dict.__repr__(self))
+return '<%s at 0x%x %s>' % (
+self.__class__.__name__, id(self), dict.__repr__(self))
 def __init__(self):
 super(Scope, self).__init__()
 class ClassScope(Scope):
 self.filename = filename
 self.scopeStack = [ModuleScope()]
 self.futuresAllowed = True
 if isinstance(module, str):
-module = compiler.parse(module)
+module = ast.parse(module, filename, "exec")
 self.handleChildren(module)
 self._runDeferred(self._deferredFunctions)
 # Set _deferredFunctions to None so that deferFunction will fail
 # noisily if called after we've run through the deferred functions.
 self._deferredFunctions = None
 def report(self, messageClass, *args, **kwargs):
 self.messages.append(messageClass(self.filename, *args, **kwargs))
 def handleChildren(self, tree):
-for node in tree.getChildNodes():
+for node in iter_child_nodes(tree):
 self.handleNode(node, tree)
+def isDocstring(self, node):
+"""
+Determine if the given node is a docstring, as long as it is at the
+correct place in the node tree.
+"""
+return isinstance(node, _ast.Str) or \
+(isinstance(node, _ast.Expr) and
+isinstance(node.value, _ast.Str))
 def handleNode(self, node, parent):
 node.parent = parent
 if self.traceTree:
 print '  ' * self.nodeDepth + node.__class__.__name__
 self.nodeDepth += 1
+if self.futuresAllowed and not \
+(isinstance(node, _ast.ImportFrom) or self.isDocstring(node)):
+self.futuresAllowed = False
 nodeType = node.__class__.__name__.upper()
-if nodeType not in ('STMT', 'FROM'):
-self.futuresAllowed = False
 try:
 handler = getattr(self, nodeType)
 handler(node)
 finally:
 self.nodeDepth -= 1
 print '  ' * self.nodeDepth + 'end ' + node.__class__.__name__
 def ignore(self, node):
 pass
-STMT = PRINT = PRINTNL = TUPLE = LIST = ASSTUPLE = ASSATTR = \
+# "stmt" type nodes
-ASSLIST = GETATTR = SLICE = SLICEOBJ = IF = CALLFUNC = DISCARD = \
+RETURN = DELETE = PRINT = WHILE = IF = WITH = RAISE = TRYEXCEPT = \
-RETURN = ADD = MOD = SUB = NOT = UNARYSUB = INVERT = ASSERT = COMPARE = \
+TRYFINALLY = ASSERT = EXEC = EXPR = handleChildren
-SUBSCRIPT = AND = OR = TRYEXCEPT = RAISE = YIELD = DICT = LEFTSHIFT = \
-RIGHTSHIFT = KEYWORD = TRYFINALLY = WHILE = EXEC = MUL = DIV = POWER = \
+CONTINUE = BREAK = PASS = ignore
-FLOORDIV = BITAND = BITOR = BITXOR = LISTCOMPFOR = LISTCOMPIF = \
-AUGASSIGN = BACKQUOTE = UNARYADD = GENEXPR = GENEXPRFOR = GENEXPRIF = \
+# "expr" type nodes
-IFEXP = handleChildren
+BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = YIELD = COMPARE = \
+CALL = REPR = ATTRIBUTE = SUBSCRIPT = LIST = TUPLE = handleChildren
-CONST = PASS = CONTINUE = BREAK = ELLIPSIS = ignore
+NUM = STR = ELLIPSIS = ignore
+# "slice" type nodes
+SLICE = EXTSLICE = INDEX = handleChildren
+# expression contexts are node instances too, though being constants
+LOAD = STORE = DEL = AUGLOAD = AUGSTORE = PARAM = ignore
+# same for operators
+AND = OR = ADD = SUB = MULT = DIV = MOD = POW = LSHIFT = RSHIFT = \
+BITOR = BITXOR = BITAND = FLOORDIV = INVERT = NOT = UADD = USUB = \
+EQ = NOTEQ = LT = LTE = GT = GTE = IS = ISNOT = IN = NOTIN = ignore
+# additional node types
+COMPREHENSION = EXCEPTHANDLER = KEYWORD = handleChildren
 def addBinding(self, lineno, value, reportRedef=True):
 '''
 Called when a binding is altered.
 if not isinstance(self.scope, ClassScope):
 for scope in self.scopeStack[::-1]:
 existing = scope.get(value.name)
 if (isinstance(existing, Importation)
 and not existing.used
-and (not isinstance(value, Importation) or value.fullName == existing.fullName)
+and (not isinstance(value, Importation) or
-and reportRedef):
+value.fullName == existing.fullName)
+and reportRedef):
 self.report(messages.RedefinedWhileUnused,
 lineno, value.name, scope[value.name].source.lineno)
 if isinstance(value, UnBinding):
 except KeyError:
 self.report(messages.UndefinedName, lineno, value.name)
 else:
 self.scope[value.name] = value
-def WITH(self, node):
-"""
-Handle 'with' by checking the target of the statement (which can be an
-identifier, a list or tuple of targets, an attribute, etc) for
-undefined names and defining any it adds to the scope and by continuing
-to process the suite within the statement.
-"""
-# Check the "foo" part of a "with foo as bar" statement.  Do this no
-# matter what, since there's always a "foo" part.
-self.handleNode(node.expr, node)
-if node.vars is not None:
-self.handleNode(node.vars, node)
-self.handleChildren(node.body)
 def GLOBAL(self, node):
 """
 Keep track of globals declarations.
 """
 if isinstance(self.scope, FunctionScope):
 self.scope.globals.update(dict.fromkeys(node.names))
 def LISTCOMP(self, node):
-for qual in node.quals:
+# handle generators before element
-self.handleNode(qual, node)
+for gen in node.generators:
-self.handleNode(node.expr, node)
+self.handleNode(gen, node)
+self.handleNode(node.elt, node)
-GENEXPRINNER = LISTCOMP
+GENERATOREXP = SETCOMP = LISTCOMP
+# dictionary comprehensions; introduced in Python 2.7
+def DICTCOMP(self, node):
+for gen in node.generators:
+self.handleNode(gen, node)
+self.handleNode(node.key, node)
+self.handleNode(node.value, node)
 def FOR(self, node):
 """
 Process bindings for loop variables.
 """
 vars = []
 def collectLoopVars(n):
-if hasattr(n, 'name'):
+if isinstance(n, _ast.Name):
-vars.append(n.name)
+vars.append(n.id)
+elif isinstance(n, _ast.expr_context):
+return
 else:
-for c in n.getChildNodes():
+for c in iter_child_nodes(n):
 collectLoopVars(c)
-collectLoopVars(node.assign)
+collectLoopVars(node.target)
 for varn in vars:
 if (isinstance(self.scope.get(varn), Importation)
 # unused ones will get an unused import warning
 and self.scope[varn].used):
 self.report(messages.ImportShadowedByLoopVar,
 def NAME(self, node):
 """
 Locate the name in locals / function / globals scopes.
 """
-# try local scope
+if isinstance(node.ctx, (_ast.Load, _ast.AugLoad)):
-importStarred = self.scope.importStarred
+# try local scope
-try:
+importStarred = self.scope.importStarred
-self.scope[node.name].used = (self.scope, node.lineno)
-except KeyError:
-pass
-else:
-return
-# try enclosing function scopes
-for scope in self.scopeStack[-2:0:-1]:
-importStarred = importStarred or scope.importStarred
-if not isinstance(scope, FunctionScope):
-continue
 try:
-scope[node.name].used = (self.scope, node.lineno)
+self.scope[node.id].used = (self.scope, node.lineno)
 except KeyError:
 pass
 else:
 return
-# try global scope
+# try enclosing function scopes
-importStarred = importStarred or self.scopeStack[0].importStarred
+for scope in self.scopeStack[-2:0:-1]:
-try:
+importStarred = importStarred or scope.importStarred
-self.scopeStack[0][node.name].used = (self.scope, node.lineno)
+if not isinstance(scope, FunctionScope):
-except KeyError:
+continue
-if ((not hasattr(__builtin__, node.name))
+try:
-and node.name not in _MAGIC_GLOBALS
+scope[node.id].used = (self.scope, node.lineno)
-and not importStarred):
+except KeyError:
-if (os.path.basename(self.filename) == '__init__.py' and
-node.name == '__path__'):
-# the special name __path__ is valid only in packages
 pass
 else:
-self.report(messages.UndefinedName, node.lineno, node.name)
+return
-def FUNCTION(self, node):
+# try global scope
-if getattr(node, "decorators", None) is not None:
-self.handleChildren(node.decorators)
+importStarred = importStarred or self.scopeStack[0].importStarred
+try:
+self.scopeStack[0][node.id].used = (self.scope, node.lineno)
+except KeyError:
+if ((not hasattr(__builtin__, node.id))
+and node.id not in _MAGIC_GLOBALS
+and not importStarred):
+if (os.path.basename(self.filename) == '__init__.py' and
+node.id == '__path__'):
+# the special name __path__ is valid only in packages
+pass
+else:
+self.report(messages.UndefinedName, node.lineno, node.id)
+elif isinstance(node.ctx, (_ast.Store, _ast.AugStore)):
+# if the name hasn't already been defined in the current scope
+if isinstance(self.scope, FunctionScope) and node.id not in self.scope:
+# for each function or module scope above us
+for scope in self.scopeStack[:-1]:
+if not isinstance(scope, (FunctionScope, ModuleScope)):
+continue
+# if the name was defined in that scope, and the name has
+# been accessed already in the current scope, and hasn't
+# been declared global
+if (node.id in scope
+and scope[node.id].used
+and scope[node.id].used[0] is self.scope
+and node.id not in self.scope.globals):
+# then it's probably a mistake
+self.report(messages.UndefinedLocal,
+scope[node.id].used[1],
+node.id,
+scope[node.id].source.lineno)
+break
+if isinstance(node.parent,
+(_ast.For, _ast.comprehension, _ast.Tuple, _ast.List)):
+binding = Binding(node.id, node)
+elif (node.id == '__all__' and
+isinstance(self.scope, ModuleScope)):
+binding = ExportBinding(node.id, node.parent.value)
+else:
+binding = Assignment(node.id, node)
+if node.id in self.scope:
+binding.used = self.scope[node.id].used
+self.addBinding(node.lineno, binding)
+elif isinstance(node.ctx, _ast.Del):
+if isinstance(self.scope, FunctionScope) and \
+node.id in self.scope.globals:
+del self.scope.globals[node.id]
+else:
+self.addBinding(node.lineno, UnBinding(node.id, node))
+else:
+# must be a Param context -- this only happens for names in function
+# arguments, but these aren't dispatched through here
+raise RuntimeError(
+"Got impossible expression context: %r" % (node.ctx,))
+def FUNCTIONDEF(self, node):
+if hasattr(node, 'decorators'):
+for deco in node.decorators:
+self.handleNode(deco, node)
+else:
+for deco in node.decorator_list:
+self.handleNode(deco, node)
 self.addBinding(node.lineno, FunctionDefinition(node.name, node))
 self.LAMBDA(node)
 def LAMBDA(self, node):
-for default in node.defaults:
+for default in node.args.defaults:
 self.handleNode(default, node)
 def runFunction():
 args = []
 def addArgs(arglist):
 for arg in arglist:
-if isinstance(arg, tuple):
+if isinstance(arg, _ast.Tuple):
-addArgs(arg)
+addArgs(arg.elts)
 else:
-if arg in args:
+if arg.id in args:
-self.report(messages.DuplicateArgument, node.lineno, arg)
+self.report(messages.DuplicateArgument, node.lineno, arg.id)
-args.append(arg)
+args.append(arg.id)
 self.pushFunctionScope()
-addArgs(node.argnames)
+addArgs(node.args.args)
+# vararg/kwarg identifiers are not Name nodes
+if node.args.vararg:
+args.append(node.args.vararg)
+if node.args.kwarg:
+args.append(node.args.kwarg)
 for name in args:
 self.addBinding(node.lineno, Argument(name, node), reportRedef=False)
-self.handleNode(node.code, node)
+if isinstance(node.body, list):
+# case for FunctionDefs
+for stmt in node.body:
+self.handleNode(stmt, node)
+else:
+# case for Lambdas
+self.handleNode(node.body, node)
 def checkUnusedAssignments():
 """
 Check to see if any assignments have not been used.
 """
 for name, binding in self.scope.iteritems():
 self.deferAssignment(checkUnusedAssignments)
 self.popScope()
 self.deferFunction(runFunction)
+def CLASSDEF(self, node):
-def CLASS(self, node):
 """
 Check names used in a class definition, including its decorators, base
 classes, and the body of its definition.  Additionally, add its name to
 the current scope.
 """
-if getattr(node, "decorators", None) is not None:
+# decorator_list is present as of Python 2.6
-self.handleChildren(node.decorators)
+for deco in getattr(node, 'decorator_list', []):
+self.handleNode(deco, node)
 for baseNode in node.bases:
 self.handleNode(baseNode, node)
+self.pushClassScope()
+for stmt in node.body:
+self.handleNode(stmt, node)
+self.popScope()
 self.addBinding(node.lineno, Binding(node.name, node))
-self.pushClassScope()
-self.handleChildren(node.code)
-self.popScope()
-def ASSNAME(self, node):
-if node.flags == 'OP_DELETE':
-if isinstance(self.scope, FunctionScope) and node.name in self.scope.globals:
-del self.scope.globals[node.name]
-else:
-self.addBinding(node.lineno, UnBinding(node.name, node))
-else:
-# if the name hasn't already been defined in the current scope
-if isinstance(self.scope, FunctionScope) and node.name not in self.scope:
-# for each function or module scope above us
-for scope in self.scopeStack[:-1]:
-if not isinstance(scope, (FunctionScope, ModuleScope)):
-continue
-# if the name was defined in that scope, and the name has
-# been accessed already in the current scope, and hasn't
-# been declared global
-if (node.name in scope
-and scope[node.name].used
-and scope[node.name].used[0] is self.scope
-and node.name not in self.scope.globals):
-# then it's probably a mistake
-self.report(messages.UndefinedLocal,
-scope[node.name].used[1],
-node.name,
-scope[node.name].source.lineno)
-break
-if isinstance(node.parent,
-(ast.For, ast.ListCompFor, ast.GenExprFor,
-ast.AssTuple, ast.AssList)):
-binding = Binding(node.name, node)
-elif (node.name == '__all__' and
-isinstance(self.scope, ModuleScope) and
-isinstance(node.parent, ast.Assign)):
-binding = ExportBinding(node.name, node.parent.expr)
-else:
-binding = Assignment(node.name, node)
-if node.name in self.scope:
-binding.used = self.scope[node.name].used
-self.addBinding(node.lineno, binding)
 def ASSIGN(self, node):
-self.handleNode(node.expr, node)
+self.handleNode(node.value, node)
-for subnode in node.nodes[::-1]:
+for target in node.targets:
-self.handleNode(subnode, node)
+self.handleNode(target, node)
+def AUGASSIGN(self, node):
+# AugAssign is awkward: must set the context explicitly and visit twice,
+# once with AugLoad context, once with AugStore context
+node.target.ctx = _ast.AugLoad()
+self.handleNode(node.target, node)
+self.handleNode(node.value, node)
+node.target.ctx = _ast.AugStore()
+self.handleNode(node.target, node)
 def IMPORT(self, node):
-for name, alias in node.names:
+for alias in node.names:
-name = alias or name
+name = alias.asname or alias.name
 importation = Importation(name, node)
 self.addBinding(node.lineno, importation)
-def FROM(self, node):
+def IMPORTFROM(self, node):
-if node.modname == '__future__':
+if node.module == '__future__':
 if not self.futuresAllowed:
-self.report(messages.LateFutureImport, node.lineno, [n[0] for n in node.names])
+self.report(messages.LateFutureImport, node.lineno,
+[n.name for n in node.names])
 else:
 self.futuresAllowed = False
-for name, alias in node.names:
+for alias in node.names:
-if name == '*':
+if alias.name == '*':
 self.scope.importStarred = True
-self.report(messages.ImportStarUsed, node.lineno, node.modname)
+self.report(messages.ImportStarUsed, node.lineno, node.module)
 continue
-name = alias or name
+name = alias.asname or alias.name
 importation = Importation(name, node)
-if node.modname == '__future__':
+if node.module == '__future__':
 importation.used = (self.scope, node.lineno)
 self.addBinding(node.lineno, importation)
 #
 # eflag: FileType = Python2

Mercurial Repositories > eric / file comparison

comparison: UtilitiesPython2/py2flakes/checker.py

UtilitiesPython2/py2flakes/checker.py