Allow __future__ in doctest

Deprecate Checker.futuresAllowed as it is now unused,
and is typically unnecessary.  The deprecated futuresAllowed
refers only to the module scope.

Add test_checker to ensure backwards compatibility for
Checker.futuresAllowed.

Author: jayvdb

pyflakes/checker.py

@@ -8,6 +8,8 @@
 import os
 import sys
 
+from warnings import warn
+
 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
@@ -141,6 +143,18 @@ def redefines(self, other):
         return isinstance(other, Definition) and self.name == other.name
 
 
+class FutureImportation(Importation):
+    """
+    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)
+        self.used = (scope, source)
+
+
 class Argument(Binding):
     """
     Represents binding a name as an argument.
@@ -237,11 +251,12 @@ class GeneratorScope(Scope):
 
 
 class ModuleScope(Scope):
-    pass
+    """Scope for a module."""
+    _futures_allowed = True
 
 
 class DoctestScope(ModuleScope):
-    pass
+    """Scope for a doctest."""
 
 
 # Globally defined names which are not attributes of the builtins module, or
@@ -293,7 +308,6 @@ def __init__(self, tree, filename='(none)', builtins=None,
         self.withDoctest = withDoctest
         self.scopeStack = [ModuleScope()]
         self.exceptHandlers = [()]
-        self.futuresAllowed = True
         self.root = tree
         self.handleChildren(tree)
         self.runDeferred(self._deferredFunctions)
@@ -308,6 +322,20 @@ def __init__(self, tree, filename='(none)', builtins=None,
         self.popScope()
         self.checkDeadScopes()
 
+    @property
+    def futuresAllowed(self):
+        """Return whether `__future__` are permitted in the module context."""
+        warn('Checker.futuresAllowed is deprecated', DeprecationWarning, 2)
+        if not isinstance(self.scope, ModuleScope):
+            return False
+        return self.scopeStack[0]._futures_allowed
+
+    @futuresAllowed.setter
+    def futuresAllowed(self, value):
+        """Disable permitting `__future__` in the module."""
+        warn('Checker.futuresAllowed is deprecated', DeprecationWarning, 2)
+        self.scopeStack[0]._futures_allowed = value
+
     def deferFunction(self, callable):
         """
         Schedule a function handler to be called just before completion.
@@ -606,9 +634,13 @@ def handleNode(self, node, parent):
             node.col_offset += self.offset[1]
         if self.traceTree:
             print('  ' * self.nodeDepth + node.__class__.__name__)
-        if self.futuresAllowed and not (isinstance(node, ast.ImportFrom) or
-                                        self.isDocstring(node)):
-            self.futuresAllowed = False
+
+        if (isinstance(self.scope, ModuleScope) and
+                self.scope._futures_allowed and
+                not (isinstance(node, ast.ImportFrom) or
+                     self.isDocstring(node))):
+            self.scope._futures_allowed = False
+
         self.nodeDepth += 1
         node.depth = self.nodeDepth
         node.parent = parent
@@ -952,21 +984,27 @@ def IMPORT(self, node):
 
     def IMPORTFROM(self, node):
         if node.module == '__future__':
-            if not self.futuresAllowed:
+            # __future__ can only appear in module/doctest scope and
+            # should not have been disabled already in handleNode and
+            # the scope must not have any other type of binding.
+            if (not isinstance(self.scope, ModuleScope) or
+                    not self.scope._futures_allowed or
+                    any(not isinstance(binding, FutureImportation)
+                        for binding in self.scope.values())):
+                self.scope._futures_allowed = False
                 self.report(messages.LateFutureImport,
                             node, [n.name for n in node.names])
-        else:
-            self.futuresAllowed = False
 
         for alias in node.names:
-            if alias.name == '*':
+            name = alias.asname or alias.name
+            if node.module == '__future__':
+                importation = FutureImportation(name, node, self.scope)
+            elif 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)
+            else:
+                importation = Importation(name, node)
             self.addBinding(node, importation)
 
     def TRY(self, node):

pyflakes/test/harness.py

@@ -19,10 +19,14 @@
 class TestCase(unittest.TestCase):
 
     withDoctest = False
+    checker_cls = checker.Checker
 
     def flakes(self, input, *expectedOutputs, **kw):
         tree = compile(textwrap.dedent(input), "<test>", "exec", PyCF_ONLY_AST)
-        w = checker.Checker(tree, withDoctest=self.withDoctest, **kw)
+        if 'withDoctest' not in kw:
+            kw['withDoctest'] = self.withDoctest
+
+        w = self.checker_cls(tree, **kw)
         outputs = [type(o) for o in w.messages]
         expectedOutputs = list(expectedOutputs)
         outputs.sort(key=lambda t: t.__name__)

pyflakes/test/test_checker.py

@@ -0,0 +1,88 @@
+"""Tests for L{pyflakes.checker}."""
+
+from pyflakes.checker import Checker, getNodeName
+from pyflakes.test.harness import TestCase
+
+
+class StoredKwargsChecker(Checker):
+
+    """Checker that stores keyword arguments for use in tests."""
+
+    def __init__(self, tree, withDoctest, **kwargs):
+        self._test_result = None
+        if 'test_result' in kwargs:
+            self._test_result = kwargs['test_result']
+            del kwargs['test_result']
+        self._test_kwargs = kwargs
+        super(StoredKwargsChecker, self).__init__(
+            tree, withDoctest=withDoctest)
+
+
+class DeprecatedFuturesAllowedChecker(StoredKwargsChecker):
+
+    """
+    Checker that ignores tree and injects a deferred function.
+
+    Args:
+        capture_at: node to activate state capture
+        enable_at: node to force enabling of futures
+    """
+
+    def NAME(self, node):
+        name = getNodeName(node)
+        if self._test_result is None:
+            if name == self._test_kwargs['capture_at']:
+                self._test_result = self.futuresAllowed
+        super(DeprecatedFuturesAllowedChecker, self).NAME(node)
+
+    def IMPORTFROM(self, node):
+        name = node.module
+        if name == self._test_kwargs.get('enable_at'):
+            self.futuresAllowed = True
+
+        if self._test_result is None:
+            if name == self._test_kwargs['capture_at']:
+                self._test_result = self.futuresAllowed
+        super(DeprecatedFuturesAllowedChecker, self).IMPORTFROM(node)
+
+    def STR(self, node):
+        name = node.s
+        if self._test_result is None:
+            if name == self._test_kwargs['capture_at']:
+                self._test_result = self.futuresAllowed
+
+
+class TestFuturesAllowed(TestCase):
+    """Tests for L{Checker} futuresAllowed flag."""
+
+    checker_cls = DeprecatedFuturesAllowedChecker
+
+    def test_future_at_beginning(self):
+        """The futuresAllowed enabled initially."""
+        checker = self.flakes('''
+        """docstring allowed."""
+        from __future__ import print_function
+        ''', capture_at='__future__')
+
+        assert checker._test_result is True
+
+    def test_future_disabled_after_node(self):
+        """The futuresAllowed disabled after node."""
+        checker = self.flakes('1\nf = 1', capture_at='f')
+
+        assert hasattr(checker, '_test_result')
+        assert checker._test_result is False
+
+        checker = self.flakes('def f(): a = 1; return a', capture_at='a')
+
+        assert checker._test_result is False
+
+    def test_future_set_allowed(self):
+        """Set futuresAllowed permitted."""
+        checker = self.flakes('''
+        1
+        from __future__ import print_function
+        a = 1
+        ''', enable_at='__future__', capture_at='a')
+
+        assert checker._test_result is False

pyflakes/test/test_doctests.py

@@ -363,16 +363,13 @@ def func():
 
 
 class TestOther(_DoctestMixin, TestOther):
+    """Run TestOther with each test wrapped in a doctest."""
     pass
 
 
 class TestImports(_DoctestMixin, TestImports):
-
-    def test_futureImport(self):
-        """XXX This test can't work in a doctest"""
-
-    def test_futureImportUsed(self):
-        """XXX This test can't work in a doctest"""
+    """Run TestImports with each test wrapped in a doctest."""
+    pass
 
 
 class TestUndefinedNames(_DoctestMixin, TestUndefinedNames):