eric: comparison Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py

-:3224f20d8eb0
+:76f2b46437a6
 node, value.name, existing.source)
 elif isinstance(existing, Importation) and value.redefines(existing):
 existing.redefined.append(node)
+if value.name in self.scope:
+# then assume the rebound name is used as a global or within a loop
+value.used = self.scope[value.name].used
 self.scope[value.name] = value
 def getNodeHandler(self, node_class):
 try:
 return self._nodeHandlers[node_class]
 pass
 else:
 return
 scopes = [scope for scope in self.scopeStack[:-1]
-if isinstance(scope, (FunctionScope, ModuleScope))]
+if isinstance(scope, (FunctionScope, ModuleScope, GeneratorScope))]
 if isinstance(self.scope, GeneratorScope) and scopes[-1] != self.scopeStack[-2]:
 scopes.append(self.scopeStack[-2])
 # try enclosing function scopes and global scope
 importStarred = self.scope.importStarred
 binding = Binding(name, node)
 elif name == '__all__' and isinstance(self.scope, ModuleScope):
 binding = ExportBinding(name, node.parent, self.scope)
 else:
 binding = Assignment(name, node)
-if name in self.scope:
-binding.used = self.scope[name].used
 self.addBinding(node, binding)
 def handleNodeDelete(self, node):
+def on_conditional_branch():
+"""
+Return `True` if node is part of a conditional body.
+"""
+current = getattr(node, 'parent', None)
+while current:
+if isinstance(current, (ast.If, ast.While, ast.IfExp)):
+return True
+current = getattr(current, 'parent', None)
+return False
 name = getNodeName(node)
 if not name:
 return
+if on_conditional_branch():
+# We can not predict if this conditional branch is going to
+# be executed.
+return
 if isinstance(self.scope, FunctionScope) and name in self.scope.globals:
 self.scope.globals.remove(name)
 else:
 try:
 del self.scope[name]
 def ignore(self, node):
 pass
 # "stmt" type nodes
 DELETE = PRINT = FOR = ASYNCFOR = WHILE = IF = WITH = WITHITEM = \
-ASYNCWITH = RAISE = TRYFINALLY = ASSERT = EXEC = EXPR = \
+ASYNCWITH = ASYNCWITHITEM = RAISE = TRYFINALLY = ASSERT = EXEC = \
-ASSIGN = handleChildren
+EXPR = ASSIGN = handleChildren
 CONTINUE = BREAK = PASS = ignore
 # "expr" type nodes
 BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = \
 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
-LISTCOMP = COMPREHENSION = KEYWORD = handleChildren
+COMPREHENSION = KEYWORD = handleChildren
 def GLOBAL(self, node):
 """
 Keep track of globals declarations.
 """
-if isinstance(self.scope, FunctionScope):
+# In doctests, the global scope is an anonymous function at index 1.
-self.scope.globals.update(node.names)
+global_scope_index = 0#1 if self.withDoctest else 0
+global_scope = self.scopeStack[global_scope_index]
+# Ignore 'global' statement in global scope.
+if self.scope is not global_scope:
+# One 'global' statement can bind multiple (comma-delimited) names.
+for node_name in node.names:
+node_value = Assignment(node_name, node)
+# Remove UndefinedName messages already reported for this name.
+self.messages = [
+m for m in self.messages if not
+isinstance(m, messages.UndefinedName) and not
+m.message_args[0] == node_name]
+# Bind name to global scope if it doesn't exist already.
+global_scope.setdefault(node_name, node_value)
+# Bind name to non-global scopes, but as already "used".
+node_value.used = (global_scope, node)
+for scope in self.scopeStack[global_scope_index + 1:]:
+scope[node_name] = node_value
+if isinstance(scope, FunctionScope):
+scope.globals.add(node_name)
 NONLOCAL = GLOBAL
 def GENERATOREXP(self, node):
 self.pushScope(GeneratorScope)
 self.handleChildren(node)
 self.popScope()
+LISTCOMP = handleChildren if PY2 else GENERATOREXP
 DICTCOMP = SETCOMP = GENERATOREXP
 def NAME(self, node):
 """
 # 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 RETURN(self, node):
+if isinstance(self.scope, ClassScope):
+self.report(messages.ReturnOutsideFunction, node)
+return
 if (
 node.value and
 hasattr(self.scope, 'returnValue') and
 not self.scope.returnValue
 ):
 def YIELD(self, node):
 self.scope.isGenerator = True
 self.handleNode(node.value, node)
-YIELDFROM = YIELD
+AWAIT = YIELDFROM = YIELD
 def FUNCTIONDEF(self, node):
 for deco in node.decorator_list:
 self.handleNode(deco, node)
 self.LAMBDA(node)

Mercurial Repositories > eric / file comparison

comparison: Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py

Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py