Update pyflakes to 1.0.0

Author: Vladimir Rudnyh

contrib/pyflakes/__init__.py

@@ -1,2 +1 @@
-
-__version__ = '0.8.2a0'
+__version__ = '1.0.0'

contrib/pyflakes/api.py

@@ -73,7 +73,16 @@ def checkPath(filename, reporter=None):
     if reporter is None:
         reporter = modReporter._makeDefaultReporter()
     try:
-        with open(filename, 'rb') as f:
+        # in Python 2.6, compile() will choke on \r\n line endings. In later
+        # versions of python it's smarter, and we want binary mode to give
+        # compile() the best opportunity to do the right thing WRT text
+        # encodings.
+        if sys.version_info < (2, 7):
+            mode = 'rU'
+        else:
+            mode = 'rb'
+
+        with open(filename, mode) as f:
             codestr = f.read()
         if sys.version_info < (2, 7):
             codestr += '\n'     # Work around for Python <= 2.6
@@ -121,17 +130,40 @@ def checkRecursive(paths, reporter):
     return warnings
 
 
+def _exitOnSignal(sigName, message):
+    """Handles a signal with sys.exit.
+
+    Some of these signals (SIGPIPE, for example) don't exist or are invalid on
+    Windows. So, ignore errors that might arise.
+    """
+    import signal
+
+    try:
+        sigNumber = getattr(signal, sigName)
+    except AttributeError:
+        # the signal constants defined in the signal module are defined by
+        # whether the C library supports them or not. So, SIGPIPE might not
+        # even be defined.
+        return
+
+    def handler(sig, f):
+        sys.exit(message)
+
+    try:
+        signal.signal(sigNumber, handler)
+    except ValueError:
+        # It's also possible the signal is defined, but then it's invalid. In
+        # this case, signal.signal raises ValueError.
+        pass
+
+
 def main(prog=None):
     """Entry point for the script "pyflakes"."""
     import optparse
-    import signal
 
     # Handle "Keyboard Interrupt" and "Broken pipe" gracefully
-    try:
-        signal.signal(signal.SIGINT, lambda sig, f: sys.exit('... stopped'))
-        signal.signal(signal.SIGPIPE, lambda sig, f: sys.exit(1))
-    except ValueError:
-        pass    # SIGPIPE is not supported on Windows
+    _exitOnSignal('SIGINT', '... stopped')
+    _exitOnSignal('SIGPIPE', 1)
 
     parser = optparse.OptionParser(prog=prog, version=__version__)
     (__, args) = parser.parse_args()

contrib/pyflakes/checker.py

@@ -448,6 +448,10 @@ def addBinding(self, node, value):
             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):
@@ -471,7 +475,7 @@ def handleNodeLoad(self, node):
             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])
 
@@ -526,14 +530,30 @@ def handleNodeStore(self, node):
             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:
@@ -630,8 +650,9 @@ def ignore(self, node):
         pass
 
     # "stmt" type nodes
-    DELETE = PRINT = FOR = WHILE = IF = WITH = WITHITEM = RAISE = \
-        TRYFINALLY = ASSERT = EXEC = EXPR = ASSIGN = handleChildren
+    DELETE = PRINT = FOR = ASYNCFOR = WHILE = IF = WITH = WITHITEM = \
+        ASYNCWITH = ASYNCWITHITEM = RAISE = TRYFINALLY = ASSERT = EXEC = \
+        EXPR = ASSIGN = handleChildren
 
     CONTINUE = BREAK = PASS = ignore
 
@@ -654,14 +675,36 @@ def ignore(self, node):
         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):
-            self.scope.globals.update(node.names)
+        # In doctests, the global scope is an anonymous function at index 1.
+        global_scope_index = 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
 
     NONLOCAL = GLOBAL
 
@@ -670,6 +713,8 @@ def GENERATOREXP(self, node):
         self.handleChildren(node)
         self.popScope()
 
+    LISTCOMP = handleChildren if PY2 else GENERATOREXP
+
     DICTCOMP = SETCOMP = GENERATOREXP
 
     def NAME(self, node):
@@ -693,6 +738,10 @@ def NAME(self, node):
             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
@@ -705,7 +754,7 @@ 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:
@@ -715,6 +764,8 @@ def FUNCTIONDEF(self, node):
         if self.withDoctest:
             self.deferFunction(lambda: self.handleDoctests(node))
 
+    ASYNCFUNCTIONDEF = FUNCTIONDEF
+
     def LAMBDA(self, node):
         args = []
         annotations = []

contrib/pyflakes/messages.py

@@ -100,14 +100,6 @@ def __init__(self, filename, loc, name):
         self.message_args = (name,)
 
 
-class Redefined(Message):
-    message = 'redefinition of %r from line %r'
-
-    def __init__(self, filename, loc, name, orig_loc):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name, orig_loc.lineno)
-
-
 class LateFutureImport(Message):
     message = 'future import(s) %r after other statements'
 
@@ -133,3 +125,10 @@ class ReturnWithArgsInsideGenerator(Message):
     Indicates a return statement with arguments inside a generator.
     """
     message = '\'return\' with argument inside generator'
+
+
+class ReturnOutsideFunction(Message):
+    """
+    Indicates a return statement outside of a function/method.
+    """
+    message = '\'return\' outside function'

contrib/pyflakes/test/test_api.py

@@ -15,7 +15,7 @@
     checkRecursive,
     iterSourceCode,
 )
-from pyflakes.test.harness import TestCase
+from pyflakes.test.harness import TestCase, skipIf
 
 if sys.version_info < (3,):
     from cStringIO import StringIO
@@ -385,12 +385,18 @@ def test_nonKeywordAfterKeywordSyntaxError(self):
         sourcePath = self.makeTempFile(source)
         last_line = '            ^\n' if sys.version_info >= (3, 2) else ''
         column = '13:' if sys.version_info >= (3, 2) else ''
+
+        if sys.version_info >= (3, 5):
+            message = 'positional argument follows keyword argument'
+        else:
+            message = 'non-keyword arg after keyword arg'
+
         self.assertHasErrors(
             sourcePath,
             ["""\
-%s:1:%s non-keyword arg after keyword arg
+%s:1:%s %s
 foo(bar=baz, bax)
-%s""" % (sourcePath, column, last_line)])
+%s""" % (sourcePath, column, message, last_line)])
 
     def test_invalidEscape(self):
         """
@@ -413,6 +419,7 @@ def test_invalidEscape(self):
         self.assertHasErrors(
             sourcePath, [decoding_error])
 
+    @skipIf(sys.platform == 'win32', 'unsupported on Windows')
     def test_permissionDenied(self):
         """
         If the source file is not readable, this is reported on standard
@@ -449,6 +456,13 @@ def test_encodedFileUTF8(self):
         sourcePath = self.makeTempFile(source)
         self.assertHasErrors(sourcePath, [])
 
+    def test_CRLFLineEndings(self):
+        """
+        Source files with Windows CR LF line endings are parsed successfully.
+        """
+        sourcePath = self.makeTempFile("x = 42\r\n")
+        self.assertHasErrors(sourcePath, [])
+
     def test_misencodedFileUTF8(self):
         """
         If a source file contains bytes which cannot be decoded, this is
@@ -570,7 +584,7 @@ def test_fileWithFlakes(self):
         fd.close()
         d = self.runPyflakes([self.tempfilepath])
         expected = UnusedImport(self.tempfilepath, Node(1), 'contraband')
-        self.assertEqual(d, ("%s\n" % expected, '', 1))
+        self.assertEqual(d, ("%s%s" % (expected, os.linesep), '', 1))
 
     def test_errors(self):
         """
@@ -579,7 +593,8 @@ def test_errors(self):
         printed to stderr.
         """
         d = self.runPyflakes([self.tempfilepath])
-        error_msg = '%s: No such file or directory\n' % (self.tempfilepath,)
+        error_msg = '%s: No such file or directory%s' % (self.tempfilepath,
+                                                         os.linesep)
         self.assertEqual(d, ('', error_msg, 1))
 
     def test_readFromStdin(self):
@@ -588,4 +603,4 @@ def test_readFromStdin(self):
         """
         d = self.runPyflakes([], stdin='import contraband'.encode('ascii'))
         expected = UnusedImport('<stdin>', Node(1), 'contraband')
-        self.assertEqual(d, ("%s\n" % expected, '', 1))
+        self.assertEqual(d, ("%s%s" % (expected, os.linesep), '', 1))

contrib/pyflakes/test/test_doctests.py

@@ -64,7 +64,7 @@ def doctest_stuff():
             """
 
         foo
-        ''', m.Redefined)
+        ''', m.RedefinedWhileUnused)
 
     def test_importInDoctestAndAfter(self):
         self.flakes('''

contrib/pyflakes/test/test_imports.py

@@ -473,6 +473,8 @@ def test_usedInListComp(self):
         self.flakes('import fu; [fu for _ in range(1)]')
         self.flakes('import fu; [1 for _ in range(1) if fu]')
 
+    @skipIf(version_info >= (3,),
+            'in Python 3 list comprehensions execute in a separate scope')
     def test_redefinedByListComp(self):
         self.flakes('import fu; [1 for fu in range(1)]',
                     m.RedefinedInListComp)
@@ -503,11 +505,36 @@ def test_usedInWhile(self):
         ''')
 
     def test_usedInGlobal(self):
+        """
+        A 'global' statement shadowing an unused import should not prevent it
+        from being reported.
+        """
         self.flakes('''
         import fu
         def f(): global fu
         ''', m.UnusedImport)
 
+    def test_usedAndGlobal(self):
+        """
+        A 'global' statement shadowing a used import should not cause it to be
+        reported as unused.
+        """
+        self.flakes('''
+            import foo
+            def f(): global foo
+            def g(): foo.is_used()
+        ''')
+
+    def test_assignedToGlobal(self):
+        """
+        Binding an import to a declared global should not cause it to be
+        reported as unused.
+        """
+        self.flakes('''
+            def f(): global foo; import foo
+            def g(): foo.is_used()
+        ''')
+
     @skipIf(version_info >= (3,), 'deprecated syntax')
     def test_usedInBackquote(self):
         self.flakes('import fu; `fu`')