Allow __future__ in doctest

Replaces plain attribute Checker.futuresAllowed with a property
that supports __future__ in both module and doctest.

Author: jayvdb

pyflakes/checker.py

@@ -147,6 +147,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.
@@ -244,6 +256,7 @@ class GeneratorScope(Scope):
 
 class ModuleScope(Scope):
     """Scope for a module."""
+    _futures_allowed = True
 
 
 class DoctestScope(ModuleScope):
@@ -299,7 +312,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)
@@ -314,6 +326,28 @@ def __init__(self, tree, filename='(none)', builtins=None,
         self.popScope()
         self.checkDeadScopes()
 
+    @property
+    def futuresAllowed(self):
+        if len(self.scopeStack) > 2:
+            return False
+
+        if not all(isinstance(scope, ModuleScope)
+                   for scope in self.scopeStack):
+            return False
+
+        if not self.scope._futures_allowed:
+            return False
+
+        return all(isinstance(binding, FutureImportation)
+                   for binding in self.scope.values())
+
+    @futuresAllowed.setter
+    def futuresAllowed(self, value):
+        assert value == False
+        if not isinstance(self.scope, ModuleScope):
+            return
+        self.scope._futures_allowed = False
+
     def deferFunction(self, callable):
         """
         Schedule a function handler to be called just before completion.
@@ -975,7 +1009,10 @@ def IMPORTFROM(self, node):
             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 == '*':
                 # Only Python 2, local import * is a SyntaxWarning
                 if not PY2 and not isinstance(self.scope, ModuleScope):
                     self.report(messages.ImportStarNotPermitted,
@@ -984,10 +1021,8 @@ def IMPORTFROM(self, node):
                 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/test_doctests.py

@@ -383,18 +383,12 @@ def func():
 
 
 class TestOther(_DoctestMixin, TestOther):
-    pass
+    """Run TestOther with each test wrapped in a doctest."""
 
 
 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."""
 
 
 class TestUndefinedNames(_DoctestMixin, TestUndefinedNames):
     """Run TestUndefinedNames with each test wrapped in a doctest."""
-    pass