Commits

Daniele Varrazzo committed 7d3e70b

vim -- pyflakes drop-in replaced with submodule

Dropped in at commit 28747f3a with pyflakes 0.6.1.

Comments (0)

Files changed (20)

 [submodule "submods/ultisnip"]
 	path = submods/ultisnip
 	url = git://github.com/vim-scripts/UltiSnips.git
+[submodule "submods/pyflakes-vim"]
+	path = submods/pyflakes-vim
+	url = git://github.com/kevinw/pyflakes-vim.git

vim/ftplugin/README.rst

-pyflakes-vim
-============
-
-A Vim plugin for checking Python code on the fly.
-
-PyFlakes catches common Python errors like mistyping a variable name or
-accessing a local before it is bound, and also gives warnings for things like
-unused imports.
-
-pyflakes-vim uses the output from PyFlakes to highlight errors in your code.
-To locate errors quickly, use quickfix_ commands like :cc.
-
-Make sure to check vim.org_ for the latest updates.
-
-.. _pyflakes.vim: http://www.vim.org/scripts/script.php?script_id=2441
-.. _vim.org: http://www.vim.org/scripts/script.php?script_id=2441
-.. _quickfix: http://vimdoc.sourceforge.net/htmldoc/quickfix.html#quickfix
-
-Quick Installation
-------------------
-
-1. Make sure your ``.vimrc`` has::
- 
-    filetype on            " enables filetype detection
-    filetype plugin on     " enables filetype specific plugins
-
-2. Download the latest release_.
-
-3. If you're using pathogen_, unzip the contents of ``pyflakes-vim.zip`` into
-   its own bundle directory, i.e. into ``~/.vim/bundle/pyflakes-vim/``.
-
-   Otherwise unzip ``pyflakes.vim`` and the ``pyflakes`` directory into
-   ``~/.vim/ftplugin/python`` (or somewhere similar on your
-   `runtime path`_ that will be sourced for Python files).
-
-.. _release: http://www.vim.org/scripts/script.php?script_id=2441
-.. _pathogen: http://www.vim.org/scripts/script.php?script_id=2332
-.. _runtime path: http://vimdoc.sourceforge.net/htmldoc/options.html#'runtimepath' 
-
-Running from source
--------------------
-
-If you're running pyflakes-vim "from source," you'll need the PyFlakes library
-on your PYTHONPATH somewhere.  (It is included in the vim.org zipfile.) I recommend
-getting my PyFlakes_ fork, which retains column number information, giving more
-specific error locations.
-
-.. _vim.org: http://www.vim.org/scripts/script.php?script_id=2441
-.. _PyFlakes: http://github.com/kevinw/pyflakes
-
-Hacking
--------
-
-::
-
-  git clone git://github.com/kevinw/pyflakes-vim.git
-  cd pyflakes-vim
-  git clone git://github.com/kevinw/pyflakes.git
-
-Options
--------
-
-Set this option to you vimrc file to disable quickfix support::
-    
-    let g:pyflakes_use_quickfix = 0
-
-The value is set to 1 by default.
-
-TODO
-----
- * signs_ support (show warning and error icons to left of the buffer area)
- * configuration variables
- * parse or intercept useful output from the warnings module
-
-.. _signs: http://www.vim.org/htmldoc/sign.html
-
-Changelog
----------
-
-Please see http://www.vim.org/scripts/script.php?script_id=2441 for a history of
-all changes.
-

vim/ftplugin/python

+../../submods/pyflakes-vim/ftplugin/python

vim/ftplugin/python/pyflakes.vim

-" pyflakes.vim - A script to highlight Python code on the fly with warnings
-" from Pyflakes, a Python lint tool.
-"
-" Place this script and the accompanying pyflakes directory in
-" .vim/ftplugin/python.
-"
-" See README for additional installation and information.
-"
-" Thanks to matlib.vim for ideas/code on interactive linting.
-"
-" Maintainer: Kevin Watters <kevin.watters@gmail.com>
-" Version: 0.1
-
-if exists("b:did_pyflakes_plugin")
-    finish " only load once
-else
-    let b:did_pyflakes_plugin = 1
-endif
-
-if !exists('g:pyflakes_builtins')
-    let g:pyflakes_builtins = []
-endif
-
-if !exists("b:did_python_init")
-    let b:did_python_init = 0
-
-    if !has('python')
-        echoerr "Error: the pyflakes.vim plugin requires Vim to be compiled with +python"
-        finish
-    endif
-
-if !exists('g:pyflakes_use_quickfix')
-    let g:pyflakes_use_quickfix = 1
-endif
-
-
-    python << EOF
-import vim
-import os.path
-import sys
-
-if sys.version_info[:2] < (2, 5):
-    raise AssertionError('Vim must be compiled with Python 2.5 or higher; you have ' + sys.version)
-
-# get the directory this script is in: the pyflakes python module should be installed there.
-scriptdir = os.path.join(os.path.dirname(vim.eval('expand("<sfile>")')), 'pyflakes')
-sys.path.insert(0, scriptdir)
-
-import ast
-from pyflakes import checker, messages
-from operator import attrgetter
-import re
-
-class loc(object):
-    def __init__(self, lineno, col=None):
-        self.lineno = lineno
-        self.col_offset = col
-
-class SyntaxError(messages.Message):
-    message = 'could not compile: %s'
-    def __init__(self, filename, lineno, col, message):
-        messages.Message.__init__(self, filename, loc(lineno, col))
-        self.message_args = (message,)
-
-class blackhole(object):
-    write = flush = lambda *a, **k: None
-
-def check(buffer):
-    filename = buffer.name
-    contents = buffer[:]
-
-    # shebang usually found at the top of the file, followed by source code encoding marker.
-    # assume everything else that follows is encoded in the encoding.
-    encoding_found = False
-    for n, line in enumerate(contents):
-        if n >= 2:
-            break
-        elif re.match(r'#.*coding[:=]\s*([-\w.]+)', line):
-            contents = ['']*(n+1) + contents[n+1:]
-            break
-
-    contents = '\n'.join(contents) + '\n'
-
-    vimenc = vim.eval('&encoding')
-    if vimenc:
-        contents = contents.decode(vimenc)
-
-    builtins = set(['__file__'])
-    try:
-        builtins.update(set(eval(vim.eval('string(g:pyflakes_builtins)'))))
-    except Exception:
-        pass
-
-    try:
-        # TODO: use warnings filters instead of ignoring stderr
-        old_stderr, sys.stderr = sys.stderr, blackhole()
-        try:
-            tree = ast.parse(contents, filename or '<unknown>')
-        finally:
-            sys.stderr = old_stderr
-    except:
-        try:
-            value = sys.exc_info()[1]
-            lineno, offset, line = value[1][1:]
-        except IndexError:
-            lineno, offset, line = 1, 0, ''
-        if line and line.endswith("\n"):
-            line = line[:-1]
-
-        return [SyntaxError(filename, lineno, offset, str(value))]
-    else:
-        # pyflakes looks to _MAGIC_GLOBALS in checker.py to see which
-        # UndefinedNames to ignore
-        old_globals = getattr(checker,' _MAGIC_GLOBALS', [])
-        checker._MAGIC_GLOBALS = set(old_globals) | builtins
-
-        w = checker.Checker(tree, filename)
-
-        checker._MAGIC_GLOBALS = old_globals
-
-        w.messages.sort(key = attrgetter('lineno'))
-        return w.messages
-
-
-def vim_quote(s):
-    return s.replace("'", "''")
-EOF
-    let b:did_python_init = 1
-endif
-
-if !b:did_python_init
-    finish
-endif
-
-au BufLeave <buffer> call s:ClearPyflakes()
-
-au BufEnter <buffer> call s:RunPyflakes()
-au InsertLeave <buffer> call s:RunPyflakes()
-au InsertEnter <buffer> call s:RunPyflakes()
-au BufWritePost <buffer> call s:RunPyflakes()
-
-au CursorHold <buffer> call s:RunPyflakes()
-au CursorHoldI <buffer> call s:RunPyflakes()
-
-au CursorHold <buffer> call s:GetPyflakesMessage()
-au CursorMoved <buffer> call s:GetPyflakesMessage()
-
-if !exists("*s:PyflakesUpdate")
-    function s:PyflakesUpdate()
-        silent call s:RunPyflakes()
-        call s:GetPyflakesMessage()
-    endfunction
-endif
-
-" Call this function in your .vimrc to update PyFlakes
-if !exists(":PyflakesUpdate")
-  command PyflakesUpdate :call s:PyflakesUpdate()
-endif
-
-" Hook common text manipulation commands to update PyFlakes
-"   TODO: is there a more general "text op" autocommand we could register
-"   for here?
-noremap <buffer><silent> dd dd:PyflakesUpdate<CR>
-noremap <buffer><silent> dw dw:PyflakesUpdate<CR>
-noremap <buffer><silent> u u:PyflakesUpdate<CR>
-noremap <buffer><silent> <C-R> <C-R>:PyflakesUpdate<CR>
-
-" WideMsg() prints [long] message up to (&columns-1) length
-" guaranteed without "Press Enter" prompt.
-if !exists("*s:WideMsg")
-    function s:WideMsg(msg)
-        let x=&ruler | let y=&showcmd
-        set noruler noshowcmd
-        redraw
-        echo strpart(a:msg, 0, &columns-1)
-        let &ruler=x | let &showcmd=y
-    endfun
-endif
-
-if !exists("*s:GetQuickFixStackCount")
-    function s:GetQuickFixStackCount()
-        let l:stack_count = 0
-        try
-            silent colder 9
-        catch /E380:/
-        endtry
-
-        try
-            for i in range(9)
-                silent cnewer
-                let l:stack_count = l:stack_count + 1
-            endfor
-        catch /E381:/
-            return l:stack_count
-        endtry
-    endfunction
-endif
-
-if !exists("*s:ActivatePyflakesQuickFixWindow")
-    function s:ActivatePyflakesQuickFixWindow()
-        try
-            silent colder 9 " go to the bottom of quickfix stack
-        catch /E380:/
-        endtry
-
-        if s:pyflakes_qf > 0
-            try
-                exe "silent cnewer " . s:pyflakes_qf
-            catch /E381:/
-                echoerr "Could not activate Pyflakes Quickfix Window."
-            endtry
-        endif
-    endfunction
-endif
-
-if !exists("*s:RunPyflakes")
-    function s:RunPyflakes()
-        highlight link PyFlakes SpellBad
-
-        if exists("b:cleared")
-            if b:cleared == 0
-                silent call s:ClearPyflakes()
-                let b:cleared = 1
-            endif
-        else
-            let b:cleared = 1
-        endif
-        
-        let b:matched = []
-        let b:matchedlines = {}
-
-        let b:qf_list = []
-        let b:qf_window_count = -1
-        
-        python << EOF
-for w in check(vim.current.buffer):
-    vim.command('let s:matchDict = {}')
-    vim.command("let s:matchDict['lineNum'] = " + str(w.lineno))
-    vim.command("let s:matchDict['message'] = '%s'" % vim_quote(w.message % w.message_args))
-    vim.command("let b:matchedlines[" + str(w.lineno) + "] = s:matchDict")
-    
-    vim.command("let l:qf_item = {}")
-    vim.command("let l:qf_item.bufnr = bufnr('%')")
-    vim.command("let l:qf_item.filename = expand('%')")
-    vim.command("let l:qf_item.lnum = %s" % str(w.lineno))
-    vim.command("let l:qf_item.text = '%s'" % vim_quote(w.message % w.message_args))
-    vim.command("let l:qf_item.type = 'E'")
-
-    if getattr(w, 'col', None) is None or isinstance(w, SyntaxError):
-        # without column information, just highlight the whole line
-        # (minus the newline)
-        vim.command(r"let s:mID = matchadd('PyFlakes', '\%" + str(w.lineno) + r"l\n\@!')")
-    else:
-        # with a column number, highlight the first keyword there
-        vim.command(r"let s:mID = matchadd('PyFlakes', '^\%" + str(w.lineno) + r"l\_.\{-}\zs\k\+\k\@!\%>" + str(w.col) + r"c')")
-
-        vim.command("let l:qf_item.vcol = 1")
-        vim.command("let l:qf_item.col = %s" % str(w.col + 1))
-
-    vim.command("call add(b:matched, s:matchDict)")
-    vim.command("call add(b:qf_list, l:qf_item)")
-EOF
-        if g:pyflakes_use_quickfix == 1
-            if exists("s:pyflakes_qf")
-                " if pyflakes quickfix window is already created, reuse it
-                call s:ActivatePyflakesQuickFixWindow()
-                call setqflist(b:qf_list, 'r')
-            else
-                " one pyflakes quickfix window for all buffer
-                call setqflist(b:qf_list, '')
-                let s:pyflakes_qf = s:GetQuickFixStackCount()
-            endif
-        endif
-
-        let b:cleared = 0
-    endfunction
-end
-
-" keep track of whether or not we are showing a message
-let b:showing_message = 0
-
-if !exists("*s:GetPyflakesMessage")
-    function s:GetPyflakesMessage()
-        let s:cursorPos = getpos(".")
-
-        " Bail if RunPyflakes hasn't been called yet.
-        if !exists('b:matchedlines')
-            return
-        endif
-
-        " if there's a message for the line the cursor is currently on, echo
-        " it to the console
-        if has_key(b:matchedlines, s:cursorPos[1])
-            let s:pyflakesMatch = get(b:matchedlines, s:cursorPos[1])
-            call s:WideMsg(s:pyflakesMatch['message'])
-            let b:showing_message = 1
-            return
-        endif
-
-        " otherwise, if we're showing a message, clear it
-        if b:showing_message == 1
-            echo
-            let b:showing_message = 0
-        endif
-    endfunction
-endif
-
-if !exists('*s:ClearPyflakes')
-    function s:ClearPyflakes()
-        let s:matches = getmatches()
-        for s:matchId in s:matches
-            if s:matchId['group'] == 'PyFlakes'
-                call matchdelete(s:matchId['id'])
-            endif
-        endfor
-        let b:matched = []
-        let b:matchedlines = {}
-        let b:cleared = 1
-    endfunction
-endif
-

vim/ftplugin/python/pyflakes/LICENSE

-
-Copyright (c) 2005 Divmod, Inc., http://www.divmod.com/
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vim/ftplugin/python/pyflakes/NEWS.txt

-0.4.0 (2009-11-25):
-  - Fix reporting for certain SyntaxErrors which lack line number
-    information.
-  - Check for syntax errors more rigorously.
-  - Support checking names used with the class decorator syntax in versions
-    of Python which have it.
-  - Detect local variables which are bound but never used.
-  - Handle permission errors when trying to read source files.
-  - Handle problems with the encoding of source files.
-  - Support importing dotted names so as not to incorrectly report them as
-    redefined unused names.
-  - Support all forms of the with statement.
-  - Consider static `__all__` definitions and avoid reporting unused names
-    if the names are listed there.
-  - Fix incorrect checking of class names with respect to the names of their
-    bases in the class statement.
-  - Support the `__path__` global in `__init__.py`.
-
-0.3.0 (2009-01-30):
-  - Display more informative SyntaxError messages.
-  - Don't hang flymake with unmatched triple quotes (only report a single
-    line of source for a multiline syntax error).
-  - Recognize __builtins__ as a defined name.
-  - Improve pyflakes support for python versions 2.3-2.5
-  - Support for if-else expressions and with statements.
-  - Warn instead of error on non-existant file paths.
-  - Check for __future__ imports after other statements.
-  - Add reporting for some types of import shadowing.
-  - Improve reporting of unbound locals

vim/ftplugin/python/pyflakes/bin/pyflakes

-#!/usr/bin/python
-
-from pyflakes.scripts.pyflakes import main
-main()

vim/ftplugin/python/pyflakes/pyflakes/__init__.py

-
-__version__ = '0.4.0'

vim/ftplugin/python/pyflakes/pyflakes/checker.py

-# -*- test-case-name: pyflakes -*-
-# (c) 2005-2010 Divmod, Inc.
-# See LICENSE file for details
-
-import __builtin__
-import os.path
-import _ast
-
-from pyflakes 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.
-
-    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
-                line number that this binding was last used
-    """
-
-    def __init__(self, name, source):
-        self.name = name
-        self.source = source
-        self.used = False
-
-
-    def __str__(self):
-        return self.name
-
-
-    def __repr__(self):
-        return '<%s object %r from line %r at 0x%x>' % (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.
-
-    @ivar fullName: The complete name given to the import statement,
-        possibly including multiple dotted components.
-    @type fullName: C{str}
-    """
-    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):
-    pass
-
-
-
-class ExportBinding(Binding):
-    """
-    A binding created by an C{__all__} assignment.  If the names in the list
-    can be determined statically, they will be treated as names for export and
-    additional checking applied to them.
-
-    The only C{__all__} assignment that can be recognized is one which takes
-    the value of a literal list containing literal strings.  For example::
-
-        __all__ = ["foo", "bar"]
-
-    Names which are imported and not otherwise used but appear in the value of
-    C{__all__} will not have an unused import warning reported for them.
-    """
-    def names(self):
-        """
-        Return a list of the names referenced by this binding.
-        """
-        names = []
-        if isinstance(self.source, _ast.List):
-            for node in self.source.elts:
-                if isinstance(node, _ast.Str):
-                    names.append(node.s)
-        return names
-
-
-
-class Scope(dict):
-    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))
-
-
-    def __init__(self):
-        super(Scope, self).__init__()
-
-
-
-class ClassScope(Scope):
-    pass
-
-
-
-class FunctionScope(Scope):
-    """
-    I represent a name scope for a function.
-
-    @ivar globals: Names declared 'global' in this function.
-    """
-    def __init__(self):
-        super(FunctionScope, self).__init__()
-        self.globals = {}
-
-
-
-class ModuleScope(Scope):
-    pass
-
-
-# Globally defined names which are not attributes of the __builtin__ module.
-_MAGIC_GLOBALS = ['__file__', '__builtins__']
-
-
-
-class Checker(object):
-    """
-    I check the cleanliness and sanity of Python code.
-
-    @ivar _deferredFunctions: Tracking list used by L{deferFunction}.  Elements
-        of the list are two-tuples.  The first element is the callable passed
-        to L{deferFunction}.  The second element is a copy of the scope stack
-        at the time L{deferFunction} was called.
-
-    @ivar _deferredAssignments: Similar to C{_deferredFunctions}, but for
-        callables which are deferred assignment checks.
-    """
-
-    nodeDepth = 0
-    traceTree = False
-
-    def __init__(self, tree, filename='(none)'):
-        self._deferredFunctions = []
-        self._deferredAssignments = []
-        self.dead_scopes = []
-        self.messages = []
-        self.filename = filename
-        self.scopeStack = [ModuleScope()]
-        self.futuresAllowed = True
-        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.
-        self._deferredFunctions = None
-        self._runDeferred(self._deferredAssignments)
-        # Set _deferredAssignments to None so that deferAssignment will fail
-        # noisly if called after we've run through the deferred assignments.
-        self._deferredAssignments = None
-        del self.scopeStack[1:]
-        self.popScope()
-        self.check_dead_scopes()
-
-
-    def deferFunction(self, callable):
-        '''
-        Schedule a function handler to be called just before completion.
-
-        This is used for handling function bodies, which must be deferred
-        because code later in the file might modify the global scope. When
-        `callable` is called, the scope at the time this is called will be
-        restored, however it will contain any new bindings added to it.
-        '''
-        self._deferredFunctions.append((callable, self.scopeStack[:]))
-
-
-    def deferAssignment(self, callable):
-        """
-        Schedule an assignment handler to be called just after deferred
-        function handlers.
-        """
-        self._deferredAssignments.append((callable, self.scopeStack[:]))
-
-
-    def _runDeferred(self, deferred):
-        """
-        Run the callables in C{deferred} using their associated scope stack.
-        """
-        for handler, scope in deferred:
-            self.scopeStack = scope
-            handler()
-
-
-    def scope(self):
-        return self.scopeStack[-1]
-    scope = property(scope)
-
-    def popScope(self):
-        self.dead_scopes.append(self.scopeStack.pop())
-
-
-    def check_dead_scopes(self):
-        """
-        Look at scopes which have been fully examined and report names in them
-        which were imported but unused.
-        """
-        for scope in self.dead_scopes:
-            export = isinstance(scope.get('__all__'), ExportBinding)
-            if export:
-                all = scope['__all__'].names()
-                if os.path.split(self.filename)[1] != '__init__.py':
-                    # Look for possible mistakes in the export list
-                    undefined = set(all) - set(scope)
-                    for name in undefined:
-                        self.report(
-                            messages.UndefinedExport,
-                            scope['__all__'].source,
-                            name)
-            else:
-                all = []
-
-            # Look for imported names that aren't used.
-            for importation in scope.itervalues():
-                if isinstance(importation, Importation):
-                    if not importation.used and importation.name not in all:
-                        self.report(
-                            messages.UnusedImport,
-                            importation.source,
-                            importation.name)
-
-
-    def pushFunctionScope(self):
-        self.scopeStack.append(FunctionScope())
-
-    def pushClassScope(self):
-        self.scopeStack.append(ClassScope())
-
-    def report(self, messageClass, *args, **kwargs):
-        self.messages.append(messageClass(self.filename, *args, **kwargs))
-
-    def handleChildren(self, tree):
-        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()
-        try:
-            handler = getattr(self, nodeType)
-            handler(node)
-        finally:
-            self.nodeDepth -= 1
-        if self.traceTree:
-            print '  ' * self.nodeDepth + 'end ' + node.__class__.__name__
-
-    def ignore(self, node):
-        pass
-
-    # "stmt" type nodes
-    RETURN = DELETE = PRINT = WHILE = IF = WITH = RAISE = TRYEXCEPT = \
-        TRYFINALLY = ASSERT = EXEC = EXPR = handleChildren
-
-    CONTINUE = BREAK = PASS = ignore
-
-    # "expr" type nodes
-    BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = YIELD = COMPARE = \
-    CALL = REPR = ATTRIBUTE = SUBSCRIPT = LIST = TUPLE = handleChildren
-
-    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, loc, value, reportRedef=True):
-        '''Called when a binding is altered.
-
-        - `loc` is the location (an object with lineno and optionally
-          col_offset attributes) of the statement responsible for the change
-        - `value` is the optional new value, a Binding instance, associated
-          with the binding; if None, the binding is deleted if it exists.
-        - if `reportRedef` is True (default), rebinding while unused will be
-          reported.
-        '''
-        if (isinstance(self.scope.get(value.name), FunctionDefinition)
-                    and isinstance(value, FunctionDefinition)):
-            self.report(messages.RedefinedFunction,
-                        loc, value.name, self.scope[value.name].source)
-
-        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 reportRedef):
-
-                    self.report(messages.RedefinedWhileUnused,
-                                loc, value.name, scope[value.name].source)
-
-        if isinstance(value, UnBinding):
-            try:
-                del self.scope[value.name]
-            except KeyError:
-                self.report(messages.UndefinedName, loc, value.name)
-        else:
-            self.scope[value.name] = value
-
-    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):
-        # handle generators before element
-        for gen in node.generators:
-            self.handleNode(gen, node)
-        self.handleNode(node.elt, node)
-
-    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 isinstance(n, _ast.Name):
-                vars.append(n.id)
-            elif isinstance(n, _ast.expr_context):
-                return
-            else:
-                for c in iter_child_nodes(n):
-                    collectLoopVars(c)
-
-        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,
-                            node, varn, self.scope[varn].source)
-
-        self.handleChildren(node)
-
-    def NAME(self, node):
-        """
-        Handle occurrence of Name (which can be a load/store/delete access.)
-        """
-        # Locate the name in locals / function / globals scopes.
-        if isinstance(node.ctx, (_ast.Load, _ast.AugLoad)):
-            # try local scope
-            importStarred = self.scope.importStarred
-            try:
-                self.scope[node.id].used = (self.scope, node)
-            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.id].used = (self.scope, node)
-                except KeyError:
-                    pass
-                else:
-                    return
-
-            # try global scope
-
-            importStarred = importStarred or self.scopeStack[0].importStarred
-            try:
-                self.scopeStack[0][node.id].used = (self.scope, node)
-            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, 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)
-                        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, 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, 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):
-        # the decorators attribute is called decorator_list as of Python 2.6
-        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, FunctionDefinition(node.name, node))
-        self.LAMBDA(node)
-
-    def LAMBDA(self, node):
-        for default in node.args.defaults:
-            self.handleNode(default, node)
-
-        def runFunction():
-            args = []
-
-            def addArgs(arglist):
-                for arg in arglist:
-                    if isinstance(arg, _ast.Tuple):
-                        addArgs(arg.elts)
-                    else:
-                        if arg.id in args:
-                            self.report(messages.DuplicateArgument,
-                                        node, arg.id)
-                        args.append(arg.id)
-
-            self.pushFunctionScope()
-            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, Argument(name, node), reportRedef=False)
-            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():
-                    if (not binding.used and not name in self.scope.globals
-                        and isinstance(binding, Assignment)):
-                        self.report(messages.UnusedVariable,
-                                    binding.source, name)
-            self.deferAssignment(checkUnusedAssignments)
-            self.popScope()
-
-        self.deferFunction(runFunction)
-
-
-    def CLASSDEF(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.
-        """
-        # decorator_list is present as of Python 2.6
-        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, Binding(node.name, node))
-
-    def ASSIGN(self, node):
-        self.handleNode(node.value, node)
-        for target in node.targets:
-            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 alias in node.names:
-            name = alias.asname or alias.name
-            importation = Importation(name, node)
-            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
-
-        for alias in node.names:
-            if alias.name == '*':
-                self.scope.importStarred = True
-                self.report(messages.ImportStarUsed, node, node.module)
-                continue
-            name = alias.asname or alias.name
-            importation = Importation(name, node)
-            if node.module == '__future__':
-                importation.used = (self.scope, node)
-            self.addBinding(node, importation)

vim/ftplugin/python/pyflakes/pyflakes/messages.py

-# (c) 2005 Divmod, Inc.  See LICENSE file for details
-
-class Message(object):
-    message = ''
-    message_args = ()
-    def __init__(self, filename, loc, use_column=True):
-        self.filename = filename
-        self.lineno = loc.lineno
-        self.col = getattr(loc, 'col_offset', None) if use_column else None
-
-    def __str__(self):
-        return '%s:%s: %s' % (self.filename, self.lineno, self.message % self.message_args)
-
-
-class UnusedImport(Message):
-    message = '%r imported but unused'
-    def __init__(self, filename, loc, name):
-        Message.__init__(self, filename, loc, use_column=False)
-        self.message_args = (name,)
-
-
-class RedefinedWhileUnused(Message):
-    message = 'redefinition of unused %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 ImportShadowedByLoopVar(Message):
-    message = 'import %r from line %r shadowed by loop variable'
-    def __init__(self, filename, loc, name, orig_loc):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name, orig_loc.lineno)
-
-
-class ImportStarUsed(Message):
-    message = "'from %s import *' used; unable to detect undefined names"
-    def __init__(self, filename, loc, modname):
-        Message.__init__(self, filename, loc)
-        self.message_args = (modname,)
-
-
-class UndefinedName(Message):
-    message = 'undefined name %r'
-    def __init__(self, filename, loc, name):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name,)
-
-
-
-class UndefinedExport(Message):
-    message = 'undefined name %r in __all__'
-    def __init__(self, filename, loc, name):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name,)
-
-
-
-class UndefinedLocal(Message):
-    message = "local variable %r (defined in enclosing scope on line %r) referenced before assignment"
-    def __init__(self, filename, loc, name, orig_loc):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name, orig_loc.lineno)
-
-
-class DuplicateArgument(Message):
-    message = 'duplicate argument %r in function definition'
-    def __init__(self, filename, loc, name):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name,)
-
-
-class RedefinedFunction(Message):
-    message = 'redefinition of function %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'
-    def __init__(self, filename, loc, names):
-        Message.__init__(self, filename, loc)
-        self.message_args = (names,)
-
-
-class UnusedVariable(Message):
-    """
-    Indicates that a variable has been explicity assigned to but not actually
-    used.
-    """
-
-    message = 'local variable %r is assigned to but never used'
-    def __init__(self, filename, loc, names):
-        Message.__init__(self, filename, loc)
-        self.message_args = (names,)

vim/ftplugin/python/pyflakes/pyflakes/scripts/__init__.py

Empty file removed.

vim/ftplugin/python/pyflakes/pyflakes/scripts/pyflakes.py

-
-"""
-Implementation of the command-line I{pyflakes} tool.
-"""
-
-import sys
-import os
-import _ast
-
-checker = __import__('pyflakes.checker').checker
-
-def check(codeString, filename):
-    """
-    Check the Python source given by C{codeString} for flakes.
-
-    @param codeString: The Python source to check.
-    @type codeString: C{str}
-
-    @param filename: The name of the file the source came from, used to report
-        errors.
-    @type filename: C{str}
-
-    @return: The number of warnings emitted.
-    @rtype: C{int}
-    """
-    # First, compile into an AST and handle syntax errors.
-    try:
-        tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
-    except SyntaxError, value:
-        msg = value.args[0]
-
-        (lineno, offset, text) = value.lineno, value.offset, value.text
-
-        # If there's an encoding problem with the file, the text is None.
-        if text is None:
-            # Avoid using msg, since for the only known case, it contains a
-            # bogus message that claims the encoding the file declared was
-            # unknown.
-            print >> sys.stderr, "%s: problem decoding source" % (filename, )
-        else:
-            line = text.splitlines()[-1]
-
-            if offset is not None:
-                offset = offset - (len(text) - len(line))
-
-            print >> sys.stderr, '%s:%d: %s' % (filename, lineno, msg)
-            print >> sys.stderr, line
-
-            if offset is not None:
-                print >> sys.stderr, " " * offset, "^"
-
-        return 1
-    else:
-        # Okay, it's syntactically valid.  Now check it.
-        w = checker.Checker(tree, filename)
-        w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
-        for warning in w.messages:
-            print warning
-        return len(w.messages)
-
-
-def checkPath(filename):
-    """
-    Check the given path, printing out any warnings detected.
-
-    @return: the number of warnings printed
-    """
-    try:
-        return check(file(filename, 'U').read() + '\n', filename)
-    except IOError, msg:
-        print >> sys.stderr, "%s: %s" % (filename, msg.args[1])
-        return 1
-
-
-def main():
-    warnings = 0
-    args = sys.argv[1:]
-    if args:
-        for arg in args:
-            if os.path.isdir(arg):
-                for dirpath, dirnames, filenames in os.walk(arg):
-                    for filename in filenames:
-                        if filename.endswith('.py'):
-                            warnings += checkPath(os.path.join(dirpath, filename))
-            else:
-                warnings += checkPath(arg)
-    else:
-        warnings += check(sys.stdin.read(), '<stdin>')
-
-    raise SystemExit(warnings > 0)

vim/ftplugin/python/pyflakes/pyflakes/test/__init__.py

Empty file removed.

vim/ftplugin/python/pyflakes/pyflakes/test/harness.py

-
-import textwrap
-import _ast
-
-from twisted.trial import unittest
-
-from pyflakes import checker
-
-
-class Test(unittest.TestCase):
-
-    def flakes(self, input, *expectedOutputs, **kw):
-        ast = compile(textwrap.dedent(input), "<test>", "exec",
-                      _ast.PyCF_ONLY_AST)
-        w = checker.Checker(ast, **kw)
-        outputs = [type(o) for o in w.messages]
-        expectedOutputs = list(expectedOutputs)
-        outputs.sort()
-        expectedOutputs.sort()
-        self.assert_(outputs == expectedOutputs, '''\
-for input:
-%s
-expected outputs:
-%s
-but got:
-%s''' % (input, repr(expectedOutputs), '\n'.join([str(o) for o in w.messages])))
-        return w

vim/ftplugin/python/pyflakes/pyflakes/test/test_imports.py

-
-from sys import version_info
-
-from pyflakes import messages as m
-from pyflakes.test import harness
-
-class Test(harness.Test):
-
-    def test_unusedImport(self):
-        self.flakes('import fu, bar', m.UnusedImport, m.UnusedImport)
-        self.flakes('from baz import fu, bar', m.UnusedImport, m.UnusedImport)
-
-    def test_aliasedImport(self):
-        self.flakes('import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport)
-        self.flakes('from moo import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport)
-
-    def test_usedImport(self):
-        self.flakes('import fu; print fu')
-        self.flakes('from baz import fu; print fu')
-
-    def test_redefinedWhileUnused(self):
-        self.flakes('import fu; fu = 3', m.RedefinedWhileUnused)
-        self.flakes('import fu; del fu', m.RedefinedWhileUnused)
-        self.flakes('import fu; fu, bar = 3', m.RedefinedWhileUnused)
-        self.flakes('import fu; [fu, bar] = 3', m.RedefinedWhileUnused)
-
-    def test_redefinedByFunction(self):
-        self.flakes('''
-        import fu
-        def fu():
-            pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_redefinedInNestedFunction(self):
-        """
-        Test that shadowing a global name with a nested function definition
-        generates a warning.
-        """
-        self.flakes('''
-        import fu
-        def bar():
-            def baz():
-                def fu():
-                    pass
-        ''', m.RedefinedWhileUnused, m.UnusedImport)
-
-    def test_redefinedByClass(self):
-        self.flakes('''
-        import fu
-        class fu:
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_redefinedBySubclass(self):
-        """
-        If an imported name is redefined by a class statement which also uses
-        that name in the bases list, no warning is emitted.
-        """
-        self.flakes('''
-        from fu import bar
-        class bar(bar):
-            pass
-        ''')
-
-
-    def test_redefinedInClass(self):
-        """
-        Test that shadowing a global with a class attribute does not produce a
-        warning.
-        """
-        self.flakes('''
-        import fu
-        class bar:
-            fu = 1
-        print fu
-        ''')
-
-    def test_usedInFunction(self):
-        self.flakes('''
-        import fu
-        def fun():
-            print fu
-        ''')
-
-    def test_shadowedByParameter(self):
-        self.flakes('''
-        import fu
-        def fun(fu):
-            print fu
-        ''', m.UnusedImport)
-
-        self.flakes('''
-        import fu
-        def fun(fu):
-            print fu
-        print fu
-        ''')
-
-    def test_newAssignment(self):
-        self.flakes('fu = None')
-
-    def test_usedInGetattr(self):
-        self.flakes('import fu; fu.bar.baz')
-        self.flakes('import fu; "bar".fu.baz', m.UnusedImport)
-
-    def test_usedInSlice(self):
-        self.flakes('import fu; print fu.bar[1:]')
-
-    def test_usedInIfBody(self):
-        self.flakes('''
-        import fu
-        if True: print fu
-        ''')
-
-    def test_usedInIfConditional(self):
-        self.flakes('''
-        import fu
-        if fu: pass
-        ''')
-
-    def test_usedInElifConditional(self):
-        self.flakes('''
-        import fu
-        if False: pass
-        elif fu: pass
-        ''')
-
-    def test_usedInElse(self):
-        self.flakes('''
-        import fu
-        if False: pass
-        else: print fu
-        ''')
-
-    def test_usedInCall(self):
-        self.flakes('import fu; fu.bar()')
-
-    def test_usedInClass(self):
-        self.flakes('''
-        import fu
-        class bar:
-            bar = fu
-        ''')
-
-    def test_usedInClassBase(self):
-        self.flakes('''
-        import fu
-        class bar(object, fu.baz):
-            pass
-        ''')
-
-    def test_notUsedInNestedScope(self):
-        self.flakes('''
-        import fu
-        def bleh():
-            pass
-        print fu
-        ''')
-
-    def test_usedInFor(self):
-        self.flakes('''
-        import fu
-        for bar in range(9):
-            print fu
-        ''')
-
-    def test_usedInForElse(self):
-        self.flakes('''
-        import fu
-        for bar in range(10):
-            pass
-        else:
-            print fu
-        ''')
-
-    def test_redefinedByFor(self):
-        self.flakes('''
-        import fu
-        for fu in range(2):
-            pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_shadowedByFor(self):
-        """
-        Test that shadowing a global name with a for loop variable generates a
-        warning.
-        """
-        self.flakes('''
-        import fu
-        fu.bar()
-        for fu in ():
-            pass
-        ''', m.ImportShadowedByLoopVar)
-
-    def test_shadowedByForDeep(self):
-        """
-        Test that shadowing a global name with a for loop variable nested in a
-        tuple unpack generates a warning.
-        """
-        self.flakes('''
-        import fu
-        fu.bar()
-        for (x, y, z, (a, b, c, (fu,))) in ():
-            pass
-        ''', m.ImportShadowedByLoopVar)
-
-    def test_usedInReturn(self):
-        self.flakes('''
-        import fu
-        def fun():
-            return fu
-        ''')
-
-    def test_usedInOperators(self):
-        self.flakes('import fu; 3 + fu.bar')
-        self.flakes('import fu; 3 % fu.bar')
-        self.flakes('import fu; 3 - fu.bar')
-        self.flakes('import fu; 3 * fu.bar')
-        self.flakes('import fu; 3 ** fu.bar')
-        self.flakes('import fu; 3 / fu.bar')
-        self.flakes('import fu; 3 // fu.bar')
-        self.flakes('import fu; -fu.bar')
-        self.flakes('import fu; ~fu.bar')
-        self.flakes('import fu; 1 == fu.bar')
-        self.flakes('import fu; 1 | fu.bar')
-        self.flakes('import fu; 1 & fu.bar')
-        self.flakes('import fu; 1 ^ fu.bar')
-        self.flakes('import fu; 1 >> fu.bar')
-        self.flakes('import fu; 1 << fu.bar')
-
-    def test_usedInAssert(self):
-        self.flakes('import fu; assert fu.bar')
-
-    def test_usedInSubscript(self):
-        self.flakes('import fu; fu.bar[1]')
-
-    def test_usedInLogic(self):
-        self.flakes('import fu; fu and False')
-        self.flakes('import fu; fu or False')
-        self.flakes('import fu; not fu.bar')
-
-    def test_usedInList(self):
-        self.flakes('import fu; [fu]')
-
-    def test_usedInTuple(self):
-        self.flakes('import fu; (fu,)')
-
-    def test_usedInTry(self):
-        self.flakes('''
-        import fu
-        try: fu
-        except: pass
-        ''')
-
-    def test_usedInExcept(self):
-        self.flakes('''
-        import fu
-        try: fu
-        except: pass
-        ''')
-
-    def test_redefinedByExcept(self):
-        self.flakes('''
-        import fu
-        try: pass
-        except Exception, fu: pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_usedInRaise(self):
-        self.flakes('''
-        import fu
-        raise fu.bar
-        ''')
-
-    def test_usedInYield(self):
-        self.flakes('''
-        import fu
-        def gen():
-            yield fu
-        ''')
-
-    def test_usedInDict(self):
-        self.flakes('import fu; {fu:None}')
-        self.flakes('import fu; {1:fu}')
-
-    def test_usedInParameterDefault(self):
-        self.flakes('''
-        import fu
-        def f(bar=fu):
-            pass
-        ''')
-
-    def test_usedInAttributeAssign(self):
-        self.flakes('import fu; fu.bar = 1')
-
-    def test_usedInKeywordArg(self):
-        self.flakes('import fu; fu.bar(stuff=fu)')
-
-    def test_usedInAssignment(self):
-        self.flakes('import fu; bar=fu')
-        self.flakes('import fu; n=0; n+=fu')
-
-    def test_usedInListComp(self):
-        self.flakes('import fu; [fu for _ in range(1)]')
-        self.flakes('import fu; [1 for _ in range(1) if fu]')
-
-    def test_redefinedByListComp(self):
-        self.flakes('import fu; [1 for fu in range(1)]', m.RedefinedWhileUnused)
-
-
-    def test_usedInTryFinally(self):
-        self.flakes('''
-        import fu
-        try: pass
-        finally: fu
-        ''')
-
-        self.flakes('''
-        import fu
-        try: fu
-        finally: pass
-        ''')
-
-    def test_usedInWhile(self):
-        self.flakes('''
-        import fu
-        while 0:
-            fu
-        ''')
-
-        self.flakes('''
-        import fu
-        while fu: pass
-        ''')
-
-    def test_usedInGlobal(self):
-        self.flakes('''
-        import fu
-        def f(): global fu
-        ''', m.UnusedImport)
-
-    def test_usedInBackquote(self):
-        self.flakes('import fu; `fu`')
-
-    def test_usedInExec(self):
-        self.flakes('import fu; exec "print 1" in fu.bar')
-
-    def test_usedInLambda(self):
-        self.flakes('import fu; lambda: fu')
-
-    def test_shadowedByLambda(self):
-        self.flakes('import fu; lambda fu: fu', m.UnusedImport)
-
-    def test_usedInSliceObj(self):
-        self.flakes('import fu; "meow"[::fu]')
-
-    def test_unusedInNestedScope(self):
-        self.flakes('''
-        def bar():
-            import fu
-        fu
-        ''', m.UnusedImport, m.UndefinedName)
-
-    def test_methodsDontUseClassScope(self):
-        self.flakes('''
-        class bar:
-            import fu
-            def fun(self):
-                fu
-        ''', m.UnusedImport, m.UndefinedName)
-
-    def test_nestedFunctionsNestScope(self):
-        self.flakes('''
-        def a():
-            def b():
-                fu
-            import fu
-        ''')
-
-    def test_nestedClassAndFunctionScope(self):
-        self.flakes('''
-        def a():
-            import fu
-            class b:
-                def c(self):
-                    print fu
-        ''')
-
-    def test_importStar(self):
-        self.flakes('from fu import *', m.ImportStarUsed)
-
-
-    def test_packageImport(self):
-        """
-        If a dotted name is imported and used, no warning is reported.
-        """
-        self.flakes('''
-        import fu.bar
-        fu.bar
-        ''')
-
-
-    def test_unusedPackageImport(self):
-        """
-        If a dotted name is imported and not used, an unused import warning is
-        reported.
-        """
-        self.flakes('import fu.bar', m.UnusedImport)
-
-
-    def test_duplicateSubmoduleImport(self):
-        """
-        If a submodule of a package is imported twice, an unused import warning
-        and a redefined while unused warning are reported.
-        """
-        self.flakes('''
-        import fu.bar, fu.bar
-        fu.bar
-        ''', m.RedefinedWhileUnused)
-        self.flakes('''
-        import fu.bar
-        import fu.bar
-        fu.bar
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_differentSubmoduleImport(self):
-        """
-        If two different submodules of a package are imported, no duplicate
-        import warning is reported for the package.
-        """
-        self.flakes('''
-        import fu.bar, fu.baz
-        fu.bar, fu.baz
-        ''')
-        self.flakes('''
-        import fu.bar
-        import fu.baz
-        fu.bar, fu.baz
-        ''')
-
-    def test_assignRHSFirst(self):
-        self.flakes('import fu; fu = fu')
-        self.flakes('import fu; fu, bar = fu')
-        self.flakes('import fu; [fu, bar] = fu')
-        self.flakes('import fu; fu += fu')
-
-    def test_tryingMultipleImports(self):
-        self.flakes('''
-        try:
-            import fu
-        except ImportError:
-            import bar as fu
-        ''')
-    test_tryingMultipleImports.todo = ''
-
-    def test_nonGlobalDoesNotRedefine(self):
-        self.flakes('''
-        import fu
-        def a():
-            fu = 3
-            return fu
-        fu
-        ''')
-
-    def test_functionsRunLater(self):
-        self.flakes('''
-        def a():
-            fu
-        import fu
-        ''')
-
-    def test_functionNamesAreBoundNow(self):
-        self.flakes('''
-        import fu
-        def fu():
-            fu
-        fu
-        ''', m.RedefinedWhileUnused)
-
-    def test_ignoreNonImportRedefinitions(self):
-        self.flakes('a = 1; a = 2')
-
-    def test_importingForImportError(self):
-        self.flakes('''
-        try:
-            import fu
-        except ImportError:
-            pass
-        ''')
-    test_importingForImportError.todo = ''
-
-    def test_importedInClass(self):
-        '''Imports in class scope can be used through self'''
-        self.flakes('''
-        class c:
-            import i
-            def __init__(self):
-                self.i
-        ''')
-    test_importedInClass.todo = 'requires evaluating attribute access'
-
-    def test_futureImport(self):
-        '''__future__ is special'''
-        self.flakes('from __future__ import division')
-        self.flakes('''
-        "docstring is allowed before future import"
-        from __future__ import division
-        ''')
-
-    def test_futureImportFirst(self):
-        """
-        __future__ imports must come before anything else.
-        """
-        self.flakes('''
-        x = 5
-        from __future__ import division
-        ''', m.LateFutureImport)
-        self.flakes('''
-        from foo import bar
-        from __future__ import division
-        bar
-        ''', m.LateFutureImport)
-
-
-
-class TestSpecialAll(harness.Test):
-    """
-    Tests for suppression of unused import warnings by C{__all__}.
-    """
-    def test_ignoredInFunction(self):
-        """
-        An C{__all__} definition does not suppress unused import warnings in a
-        function scope.
-        """
-        self.flakes('''
-        def foo():
-            import bar
-            __all__ = ["bar"]
-        ''', m.UnusedImport, m.UnusedVariable)
-
-
-    def test_ignoredInClass(self):
-        """
-        An C{__all__} definition does not suppress unused import warnings in a
-        class scope.
-        """
-        self.flakes('''
-        class foo:
-            import bar
-            __all__ = ["bar"]
-        ''', m.UnusedImport)
-
-
-    def test_warningSuppressed(self):
-        """
-        If a name is imported and unused but is named in C{__all__}, no warning
-        is reported.
-        """
-        self.flakes('''
-        import foo
-        __all__ = ["foo"]
-        ''')
-
-
-    def test_unrecognizable(self):
-        """
-        If C{__all__} is defined in a way that can't be recognized statically,
-        it is ignored.
-        """
-        self.flakes('''
-        import foo
-        __all__ = ["f" + "oo"]
-        ''', m.UnusedImport)
-        self.flakes('''
-        import foo
-        __all__ = [] + ["foo"]
-        ''', m.UnusedImport)
-
-
-    def test_unboundExported(self):
-        """
-        If C{__all__} includes a name whi