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

-:39f27a2a2ea3
+:e2f171f08af8
 Main module.
 Implement the central Checker class.
 Also, it models the Bindings and Scopes.
 """
+import __future__
 import doctest
 import os
 import sys
 PY2 = sys.version_info < (3, 0)
 PY32 = sys.version_info < (3, 3)    # Python 2.5 to 3.2
 PY33 = sys.version_info < (3, 4)    # Python 2.5 to 3.3
+PY34 = sys.version_info < (3, 5)    # Python 2.5 to 3.4
+try:
+sys.pypy_version_info
+PYPY = True
+except AttributeError:
+PYPY = False
 builtin_vars = dir(__import__('__builtin__' if PY2 else 'builtins'))
 try:
 import ast
 except ImportError:     # Python 2.5
 if isinstance(n, ast.If):
 return [n.body]
 if isinstance(n, ast.Try):
 return [n.body + n.orelse] + [[hdl] for hdl in n.handlers]
+if PY34:
+LOOP_TYPES = (ast.While, ast.For)
+else:
+LOOP_TYPES = (ast.While, ast.For, ast.AsyncFor)
 class _FieldsOrder(dict):
 """Fix order of AST node fields."""
 def _get_fields(self, node_class):
 return tuple(sorted(fields, key=key_first, reverse=True))
 def __missing__(self, node_class):
 self[node_class] = fields = self._get_fields(node_class)
 return fields
+def counter(items):
+"""
+Simplest required implementation of collections.Counter. Required as 2.6
+does not have Counter in collections.
+"""
+results = {}
+for item in items:
+results[item] = results.get(item, 0) + 1
+return results
 def iter_child_nodes(node, omit=None, _fields_order=_FieldsOrder()):
 """
 Yield all direct child nodes of *node*, that is, all fields that
 elif isinstance(field, list):
 for item in field:
 yield item
+def convert_to_value(item):
+if isinstance(item, ast.Str):
+return item.s
+elif hasattr(ast, 'Bytes') and isinstance(item, ast.Bytes):
+return item.s
+elif isinstance(item, ast.Tuple):
+return tuple(convert_to_value(i) for i in item.elts)
+elif isinstance(item, ast.Num):
+return item.n
+elif isinstance(item, ast.Name):
+result = VariableKey(item=item)
+constants_lookup = {
+'True': True,
+'False': False,
+'None': None,
+}
+return constants_lookup.get(
+result.name,
+result,
+)
+elif (not PY33) and isinstance(item, ast.NameConstant):
+# None, True, False are nameconstants in python3, but names in 2
+return item.value
+else:
+return UnhandledKeyType()
 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
 which names have not. See L{Assignment} for a special type of binding that
 is checked with stricter rules.
-@ivar used: pair of (L{Scope}, line-number) indicating the scope and
+@ivar used: pair of (L{Scope}, node) indicating the scope and
-line number that this binding was last used
+the node that this binding was last used.
 """
 def __init__(self, name, source):
 self.name = name
 self.source = source
 """
 A binding that defines a function or a class.
 """
+class UnhandledKeyType(object):
+"""
+A dictionary key of a type that we cannot or do not check for duplicates.
+"""
+class VariableKey(object):
+"""
+A dictionary key which is a variable.
+@ivar item: The variable AST object.
+"""
+def __init__(self, item):
+self.name = item.id
+def __eq__(self, compare):
+return (
+compare.__class__ == self.__class__
+and compare.name == self.name
+)
+def __hash__(self):
+return hash(self.name)
 class Importation(Definition):
 """
 A binding created by an import statement.
 @ivar fullName: The complete name given to the import statement,
 possibly including multiple dotted components.
 @type fullName: C{str}
 """
+def __init__(self, name, source, full_name=None):
+self.fullName = full_name or name
+self.redefined = []
+super(Importation, self).__init__(name, source)
+def redefines(self, other):
+if isinstance(other, SubmoduleImportation):
+# See note in SubmoduleImportation about RedefinedWhileUnused
+return self.fullName == other.fullName
+return isinstance(other, Definition) and self.name == other.name
+def _has_alias(self):
+"""Return whether importation needs an as clause."""
+return not self.fullName.split('.')[-1] == self.name
+@property
+def source_statement(self):
+"""Generate a source statement equivalent to the import."""
+if self._has_alias():
+return 'import %s as %s' % (self.fullName, self.name)
+else:
+return 'import %s' % self.fullName
+def __str__(self):
+"""Return import full name with alias."""
+if self._has_alias():
+return self.fullName + ' as ' + self.name
+else:
+return self.fullName
+class SubmoduleImportation(Importation):
+"""
+A binding created by a submodule import statement.
+A submodule import is a special case where the root module is implicitly
+imported, without an 'as' clause, and the submodule is also imported.
+Python does not restrict which attributes of the root module may be used.
+This class is only used when the submodule import is without an 'as' clause.
+pyflakes handles this case by registering the root module name in the scope,
+allowing any attribute of the root module to be accessed.
+RedefinedWhileUnused is suppressed in `redefines` unless the submodule
+name is also the same, to avoid false positives.
+"""
 def __init__(self, name, source):
+# A dot should only appear in the name when it is a submodule import
+assert '.' in name and (not source or isinstance(source, ast.Import))
+package_name = name.split('.')[0]
+super(SubmoduleImportation, self).__init__(package_name, source)
 self.fullName = name
-self.redefined = []
-name = name.split('.')[0]
-super(Importation, self).__init__(name, source)
 def redefines(self, other):
 if isinstance(other, Importation):
 return self.fullName == other.fullName
-return isinstance(other, Definition) and self.name == other.name
+return super(SubmoduleImportation, self).redefines(other)
+def __str__(self):
+return self.fullName
+@property
+def source_statement(self):
+return 'import ' + self.fullName
+class ImportationFrom(Importation):
+def __init__(self, name, source, module, real_name=None):
+self.module = module
+self.real_name = real_name or name
+if module.endswith('.'):
+full_name = module + self.real_name
+else:
+full_name = module + '.' + self.real_name
+super(ImportationFrom, self).__init__(name, source, full_name)
+def __str__(self):
+"""Return import full name with alias."""
+if self.real_name != self.name:
+return self.fullName + ' as ' + self.name
+else:
+return self.fullName
+@property
+def source_statement(self):
+if self.real_name != self.name:
+return 'from %s import %s as %s' % (self.module,
+self.real_name,
+self.name)
+else:
+return 'from %s import %s' % (self.module, self.name)
+class StarImportation(Importation):
+"""A binding created by an 'from x import *' statement."""
+def __init__(self, name, source):
+super(StarImportation, self).__init__('*', source)
+# Each star importation needs a unique name, and
+# may not be the module name otherwise it will be deemed imported
+self.name = name + '.*'
+self.fullName = name
+@property
+def source_statement(self):
+return 'from ' + self.fullName + ' import *'
+def __str__(self):
+# When the module ends with a ., avoid the ambiguous '..*'
+if self.fullName.endswith('.'):
+return self.source_statement
+else:
+return self.name
+class FutureImportation(ImportationFrom):
+"""
+A binding created by a from `__future__` import statement.
+`__future__` imports are implicitly used.
+"""
+def __init__(self, name, source, scope):
+super(FutureImportation, self).__init__(name, source, '__future__')
+self.used = (scope, source)
 class Argument(Binding):
 """
 Represents binding a name as an argument.
 class GeneratorScope(Scope):
 pass
 class ModuleScope(Scope):
-pass
+"""Scope for a module."""
+_futures_allowed = True
+class DoctestScope(ModuleScope):
+"""Scope for a doctest."""
 # Globally defined names which are not attributes of the builtins module, or
 # are only present on some platforms.
 _MAGIC_GLOBALS = ['__file__', '__builtins__', 'WindowsError']
 def getNodeName(node):
 # Returns node.id, or node.name, or None
 if hasattr(node, 'id'):     # One of the many nodes with an id
 return node.id
-if hasattr(node, 'name'):   # a ExceptHandler node
+if hasattr(node, 'name'):   # an ExceptHandler node
 return node.name
 class Checker(object):
 """
 if builtins:
 self.builtIns = self.builtIns.union(builtins)
 self.withDoctest = withDoctest
 self.scopeStack = [ModuleScope()]
 self.exceptHandlers = [()]
-self.futuresAllowed = True
 self.root = tree
 self.handleChildren(tree)
 self.runDeferred(self._deferredFunctions)
 # Set _deferredFunctions to None so that deferFunction will fail
 # noisily if called after we've run through the deferred functions.
 for handler, scope, offset in deferred:
 self.scopeStack = scope
 self.offset = offset
 handler()
+def _in_doctest(self):
+return (len(self.scopeStack) >= 2 and
+isinstance(self.scopeStack[1], DoctestScope))
+@property
+def futuresAllowed(self):
+if not all(isinstance(scope, ModuleScope)
+for scope in self.scopeStack):
+return False
+return self.scope._futures_allowed
+@futuresAllowed.setter
+def futuresAllowed(self, value):
+assert value is False
+if isinstance(self.scope, ModuleScope):
+self.scope._futures_allowed = False
 @property
 def scope(self):
 return self.scopeStack[-1]
 def popScope(self):
 """
 Look at scopes which have been fully examined and report names in them
 which were imported but unused.
 """
 for scope in self.deadScopes:
-if isinstance(scope.get('__all__'), ExportBinding):
+# imports in classes are public members
-all_names = set(scope['__all__'].names)
+if isinstance(scope, ClassScope):
+continue
+all_binding = scope.get('__all__')
+if all_binding and not isinstance(all_binding, ExportBinding):
+all_binding = None
+if all_binding:
+all_names = set(all_binding.names)
+undefined = all_names.difference(scope)
+else:
+all_names = undefined = []
+if undefined:
 if not scope.importStarred and \
 os.path.basename(self.filename) != '__init__.py':
 # Look for possible mistakes in the export list
-undefined = all_names.difference(scope)
 for name in undefined:
 self.report(messages.UndefinedExport,
 scope['__all__'].source, name)
-else:
-all_names = []
+# mark all import '*' as used by the undefined in __all__
+if scope.importStarred:
+for binding in scope.values():
+if isinstance(binding, StarImportation):
+binding.used = all_binding
 # Look for imported names that aren't used.
 for value in scope.values():
 if isinstance(value, Importation):
 used = value.used or value.name in all_names
 if not used:
 messg = messages.UnusedImport
-self.report(messg, value.source, value.name)
+self.report(messg, value.source, str(value))
 for node in value.redefined:
 if isinstance(self.getParent(node), ast.For):
 messg = messages.ImportShadowedByLoopVar
 elif used:
 continue
 def handleNodeLoad(self, node):
 name = getNodeName(node)
 if not name:
 return
-# try local scope
-try:
+in_generators = None
-self.scope[name].used = (self.scope, node)
+importStarred = None
-except KeyError:
-pass
-else:
-return
-scopes = [scope for scope in self.scopeStack[:-1]
-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
+for scope in self.scopeStack[-1::-1]:
-for scope in reversed(scopes):
+# only generators used in a class scope can access the names
-importStarred = importStarred or scope.importStarred
+# of the class. this is skipped during the first iteration
+if in_generators is False and isinstance(scope, ClassScope):
+continue
 try:
 scope[name].used = (self.scope, node)
 except KeyError:
 pass
 else:
 return
+importStarred = importStarred or scope.importStarred
+if in_generators is not False:
+in_generators = isinstance(scope, GeneratorScope)
 # look in the built-ins
-if importStarred or name in self.builtIns:
+if name in self.builtIns:
 return
+if importStarred:
+from_list = []
+for scope in self.scopeStack[-1::-1]:
+for binding in scope.values():
+if isinstance(binding, StarImportation):
+# mark '*' imports as used for each scope
+binding.used = (self.scope, node)
+from_list.append(binding.fullName)
+# report * usage, with a list of possible sources
+from_list = ', '.join(sorted(from_list))
+self.report(messages.ImportStarUsage, node, name, from_list)
+return
 if name == '__path__' and os.path.basename(self.filename) == '__init__.py':
 # the special name __path__ is valid only in packages
 return
 # protected with a NameError handler?
 def getDocstring(self, node):
 if isinstance(node, ast.Expr):
 node = node.value
 if not isinstance(node, ast.Str):
 return (None, None)
-# Computed incorrectly if the docstring has backslash
-doctest_lineno = node.lineno - node.s.count('\n') - 1
+if PYPY:
+doctest_lineno = node.lineno - 1
+else:
+# Computed incorrectly if the docstring has backslash
+doctest_lineno = node.lineno - node.s.count('\n') - 1
 return (node.s, doctest_lineno)
 def handleNode(self, node, parent):
 if node is None:
 return
 # e.g. line 6 of the docstring for <string> has inconsistent
 # leading whitespace: ...
 return
 if not examples:
 return
+# Place doctest in module scope
+saved_stack = self.scopeStack
+self.scopeStack = [self.scopeStack[0]]
 node_offset = self.offset or (0, 0)
-self.pushScope()
+self.pushScope(DoctestScope)
 underscore_in_builtins = '_' in self.builtIns
 if not underscore_in_builtins:
 self.builtIns.add('_')
 for example in examples:
 try:
 tree = compile(example.source, "<doctest>", "exec", ast.PyCF_ONLY_AST)
 except SyntaxError:
 e = sys.exc_info()[1]
+if PYPY:
+e.offset += 1
 position = (node_lineno + example.lineno + e.lineno,
 example.indent + 4 + (e.offset or 0))
 self.report(messages.DoctestSyntaxError, node, position)
 else:
 self.offset = (node_offset[0] + node_lineno + example.lineno,
 self.handleChildren(tree)
 self.offset = node_offset
 if not underscore_in_builtins:
 self.builtIns.remove('_')
 self.popScope()
+self.scopeStack = saved_stack
 def ignore(self, node):
 pass
 # "stmt" type nodes
 DELETE = PRINT = FOR = ASYNCFOR = WHILE = IF = WITH = WITHITEM = \
-ASYNCWITH = ASYNCWITHITEM = RAISE = TRYFINALLY = ASSERT = EXEC = \
+ASYNCWITH = ASYNCWITHITEM = RAISE = TRYFINALLY = EXEC = \
 EXPR = ASSIGN = handleChildren
-CONTINUE = BREAK = PASS = ignore
+PASS = ignore
 # "expr" type nodes
-BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = \
+BOOLOP = BINOP = UNARYOP = IFEXP = SET = \
-COMPARE = CALL = REPR = ATTRIBUTE = SUBSCRIPT = LIST = TUPLE = \
+COMPARE = CALL = REPR = ATTRIBUTE = SUBSCRIPT = \
 STARRED = NAMECONSTANT = handleChildren
 NUM = STR = BYTES = ELLIPSIS = ignore
 # "slice" type nodes
 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
+EQ = NOTEQ = LT = LTE = GT = GTE = IS = ISNOT = IN = NOTIN = \
+MATMULT = ignore
 # additional node types
-COMPREHENSION = KEYWORD = handleChildren
+COMPREHENSION = KEYWORD = FORMATTEDVALUE = handleChildren
+def DICT(self, node):
+# Complain if there are duplicate keys with different values
+# If they have the same value it's not going to cause potentially
+# unexpected behaviour so we'll not complain.
+keys = [
+convert_to_value(key) for key in node.keys
+]
+key_counts = counter(keys)
+duplicate_keys = [
+key for key, count in key_counts.items()
+if count > 1
+]
+for key in duplicate_keys:
+key_indices = [i for i, i_key in enumerate(keys) if i_key == key]
+values = counter(
+convert_to_value(node.values[index])
+for index in key_indices
+)
+if any(count == 1 for value, count in values.items()):
+for key_index in key_indices:
+key_node = node.keys[key_index]
+if isinstance(key, VariableKey):
+self.report(messages.MultiValueRepeatedKeyVariable,
+key_node,
+key.name)
+else:
+self.report(
+messages.MultiValueRepeatedKeyLiteral,
+key_node,
+key,
+)
+self.handleChildren(node)
+def ASSERT(self, node):
+if isinstance(node.test, ast.Tuple) and node.test.elts != []:
+self.report(messages.AssertTuple, node)
+self.handleChildren(node)
 def GLOBAL(self, node):
 """
 Keep track of globals declarations.
 """
-# In doctests, the global scope is an anonymous function at index 1.
+global_scope_index = 1 if self._in_doctest() else 0
-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.
+# TODO: if the global is not used in this scope, it does not
+# become a globally defined name.  See test_unused_global.
 self.messages = [
 m for m in self.messages if not
 isinstance(m, messages.UndefinedName) or
 m.message_args[0] != node_name]
 # 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)
 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 CONTINUE(self, node):
+# Walk the tree up until we see a loop (OK), a function or class
+# definition (not OK), for 'continue', a finally block (not OK), or
+# the top module scope (not OK)
+n = node
+while hasattr(n, 'parent'):
+n, n_child = n.parent, n
+if isinstance(n, LOOP_TYPES):
+# Doesn't apply unless it's in the loop itself
+if n_child not in n.orelse:
+return
+if isinstance(n, (ast.FunctionDef, ast.ClassDef)):
+break
+# Handle Try/TryFinally difference in Python < and >= 3.3
+if hasattr(n, 'finalbody') and isinstance(node, ast.Continue):
+if n_child in n.finalbody:
+self.report(messages.ContinueInFinally, node)
+return
+if isinstance(node, ast.Continue):
+self.report(messages.ContinueOutsideLoop, node)
+else:  # ast.Break
+self.report(messages.BreakOutsideLoop, node)
+BREAK = CONTINUE
 def RETURN(self, node):
-if isinstance(self.scope, ClassScope):
+if isinstance(self.scope, (ClassScope, ModuleScope)):
 self.report(messages.ReturnOutsideFunction, node)
 return
 if (
 node.value and
 ):
 self.scope.returnValue = node.value
 self.handleNode(node.value, node)
 def YIELD(self, node):
+if isinstance(self.scope, (ClassScope, ModuleScope)):
+self.report(messages.YieldOutsideFunction, node)
+return
 self.scope.isGenerator = True
 self.handleNode(node.value, node)
 AWAIT = YIELDFROM = YIELD
 def FUNCTIONDEF(self, node):
 for deco in node.decorator_list:
 self.handleNode(deco, node)
 self.LAMBDA(node)
 self.addBinding(node, FunctionDefinition(node.name, node))
-if self.withDoctest:
+# doctest does not process doctest within a doctest,
+# or in nested functions.
+if (self.withDoctest and
+not self._in_doctest() and
+not isinstance(self.scope, FunctionScope)):
 self.deferFunction(lambda: self.handleDoctests(node))
 ASYNCFUNCTIONDEF = FUNCTIONDEF
 def LAMBDA(self, node):
 self.handleNode(baseNode, node)
 if not PY2:
 for keywordNode in node.keywords:
 self.handleNode(keywordNode, node)
 self.pushScope(ClassScope)
-if self.withDoctest:
+# doctest does not process doctest within a doctest
+# classes within classes are processed.
+if (self.withDoctest and
+not self._in_doctest() and
+not isinstance(self.scope, FunctionScope)):
 self.deferFunction(lambda: self.handleDoctests(node))
 for stmt in node.body:
 self.handleNode(stmt, node)
 self.popScope()
 self.addBinding(node, ClassDefinition(node.name, node))
 def AUGASSIGN(self, node):
 self.handleNodeLoad(node.target)
 self.handleNode(node.value, node)
 self.handleNode(node.target, node)
+def TUPLE(self, node):
+if not PY2 and isinstance(node.ctx, ast.Store):
+# Python 3 advanced tuple unpacking: a, *b, c = d.
+# Only one starred expression is allowed, and no more than 1<<8
+# assignments are allowed before a stared expression. There is
+# also a limit of 1<<24 expressions after the starred expression,
+# which is impossible to test due to memory restrictions, but we
+# add it here anyway
+has_starred = False
+star_loc = -1
+for i, n in enumerate(node.elts):
+if isinstance(n, ast.Starred):
+if has_starred:
+self.report(messages.TwoStarredExpressions, node)
+# The SyntaxError doesn't distinguish two from more
+# than two.
+break
+has_starred = True
+star_loc = i
+if star_loc >= 1 << 8 or len(node.elts) - star_loc - 1 >= 1 << 24:
+self.report(messages.TooManyExpressionsInStarredAssignment, node)
+self.handleChildren(node)
+LIST = TUPLE
 def IMPORT(self, node):
 for alias in node.names:
-name = alias.asname or alias.name
+if '.' in alias.name and not alias.asname:
-importation = Importation(name, node)
+importation = SubmoduleImportation(alias.name, node)
+else:
+name = alias.asname or alias.name
+importation = Importation(name, node, alias.name)
 self.addBinding(node, importation)
 def IMPORTFROM(self, node):
 if node.module == '__future__':
 if not self.futuresAllowed:
 self.report(messages.LateFutureImport,
 node, [n.name for n in node.names])
 else:
 self.futuresAllowed = False
+module = ('.' * node.level) + (node.module or '')
 for alias in node.names:
-if alias.name == '*':
+name = alias.asname or alias.name
+if node.module == '__future__':
+importation = FutureImportation(name, node, self.scope)
+if alias.name not in __future__.all_feature_names:
+self.report(messages.FutureFeatureNotDefined,
+node, alias.name)
+elif alias.name == '*':
+# Only Python 2, local import * is a SyntaxWarning
+if not PY2 and not isinstance(self.scope, ModuleScope):
+self.report(messages.ImportStarNotPermitted,
+node, module)
+continue
 self.scope.importStarred = True
-self.report(messages.ImportStarUsed, node, node.module)
+self.report(messages.ImportStarUsed, node, module)
-continue
+importation = StarImportation(module, node)
-name = alias.asname or alias.name
+else:
-importation = Importation(name, node)
+importation = ImportationFrom(name, node,
-if node.module == '__future__':
+module, alias.name)
-importation.used = (self.scope, node)
 self.addBinding(node, importation)
 def TRY(self, node):
 handler_names = []
 # List the exception handlers
-for handler in node.handlers:
+for i, handler in enumerate(node.handlers):
 if isinstance(handler.type, ast.Tuple):
 for exc_type in handler.type.elts:
 handler_names.append(getNodeName(exc_type))
 elif handler.type:
 handler_names.append(getNodeName(handler.type))
+if handler.type is None and i < len(node.handlers) - 1:
+self.report(messages.DefaultExceptNotLast, handler)
 # Memorize the except handlers and process the body
 self.exceptHandlers.append(handler_names)
 for child in node.body:
 self.handleNode(child, node)
 self.exceptHandlers.pop()
 self.handleChildren(node, omit='body')
 TRYEXCEPT = TRY
 def EXCEPTHANDLER(self, node):
-# 3.x: in addition to handling children, we must handle the name of
+if PY2 or node.name is None:
-# the exception, which is not a Name node, but a simple string.
+self.handleChildren(node)
-if isinstance(node.name, str):
+return
-self.handleNodeStore(node)
+# 3.x: the name of the exception, which is not a Name node, but
+# a simple string, creates a local that is only bound within the scope
+# of the except: block.
+for scope in self.scopeStack[::-1]:
+if node.name in scope:
+is_name_previously_defined = True
+break
+else:
+is_name_previously_defined = False
+self.handleNodeStore(node)
 self.handleChildren(node)
+if not is_name_previously_defined:
+# See discussion on https://github.com/pyflakes/pyflakes/pull/59.
+# We're removing the local name since it's being unbound
+# after leaving the except: block and it's always unbound
+# if the except: block is never entered. This will cause an
+# "undefined name" error raised if the checked code tries to
+# use the name afterwards.
+#
+# Unless it's been removed already. Then do nothing.
+try:
+del self.scope[node.name]
+except KeyError:
+pass
 #
 # eflag: noqa = M702

Mercurial Repositories > eric / file comparison

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

Plugins/CheckerPlugins/SyntaxChecker/pyflakes/checker.py