eric: comparison UtilitiesPython2/py2flakes/checker.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 import compiler
 from compiler import ast
 from py2flakes import messages
 class Binding(object):
 """
 Represents the binding of a value to a name.
 The checker uses this to keep track of which names have been bound and
 self.__class__.__name__,
 self.name,
 self.source.lineno,
 id(self))
 class UnBinding(Binding):
 '''
 Created by the 'del' operator.
 '''
 class Importation(Binding):
 """
 A binding created by an import statement.
 """
 def __init__(self, name, source):
 self.fullName = name
 name = name.split('.')[0]
 super(Importation, self).__init__(name, source)
 class Argument(Binding):
 """
 Represents binding a name as an argument.
 """
 class Assignment(Binding):
 """
 Represents binding a name with an explicit assignment.
 The checker will raise warnings for any Assignment that isn't used. Also,
 the checker does not consider assignments in tuple/list unpacking to be
 Assignments, rather it treats them as simple Bindings.
 """
 class FunctionDefinition(Binding):
 """
 Represents a function definition.
 """
 pass
 class ExportBinding(Binding):
 """
 A binding created by an __all__ assignment.  If the names in the list
 can be determined statically, they will be treated as names for export and
 for node in self.source.nodes:
 if isinstance(node, ast.Const):
 names.append(node.value)
 return names
 class Scope(dict):
 """
 Class defining the scope base class.
 """
 importStarred = False       # set to True when import * is found
 return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), dict.__repr__(self))
 def __init__(self):
 super(Scope, self).__init__()
 class ClassScope(Scope):
 """
 Class representing a name scope for a class.
 """
 pass
 class FunctionScope(Scope):
 """
 Class representing a name scope for a function.
 """
 def __init__(self):
 super(FunctionScope, self).__init__()
 self.globals = {}
 class ModuleScope(Scope):
 """
 Class representing a name scope for a module.
 """
 pass
 # Globally defined names which are not attributes of the __builtin__ module.
 _MAGIC_GLOBALS = ['__file__', '__builtins__']
 class Checker(object):
 """
 Class to check the cleanliness and sanity of Python code.
 """
 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):
 def FOR(self, node):
 """
 Process bindings for loop variables.
 """
 vars = []
 def collectLoopVars(n):
 if hasattr(n, 'name'):
 vars.append(n.name)
 else:
 for c in n.getChildNodes():
 # the special name __path__ is valid only in packages
 pass
 else:
 self.report(messages.UndefinedName, node.lineno, node.name)
 def FUNCTION(self, node):
 if getattr(node, "decorators", None) is not None:
 self.handleChildren(node.decorators)
 self.addBinding(node.lineno, FunctionDefinition(node.name, node))
 self.LAMBDA(node)
 self.pushFunctionScope()
 addArgs(node.argnames)
 for name in args:
 self.addBinding(node.lineno, Argument(name, node), reportRedef=False)
 self.handleNode(node.code, 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 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.
 self.handleNode(baseNode, node)
 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]

Mercurial Repositories > eric / file comparison

comparison: UtilitiesPython2/py2flakes/checker.py

UtilitiesPython2/py2flakes/checker.py