Omit code guarded by 'if TYPE_CHECKING'

This commit finds a problem that has been observed in read code.

Consider the following code:

```
from typing import TYPE_CHECKING
...
if TYPE_CHECKING
    from a import A, B
    from b import C

...
def f() -> "B":
    ...

def f()
    # Oops! C is actually used here.
    C()
```

This commit ignores all code that is guarded by TYPE_CHECKING in
order to find mistakes like this. This constant is always False
when mypy is not running anyway.

Author: PetterS

pyflakes/checker.py

@@ -325,6 +325,7 @@ def __init__(self, name, source):
         self.name = name
         self.source = source
         self.used = False
+        self.during_type_checking = False
 
     def __str__(self):
         return self.name
@@ -871,6 +872,7 @@ class Checker(object):
     traceTree = False
     _in_annotation = AnnotationState.NONE
     _in_deferred = False
+    _in_type_checking = False
 
     builtIns = set(builtin_vars).union(_MAGIC_GLOBALS)
     _customBuiltIns = os.environ.get('PYFLAKES_BUILTINS')
@@ -1211,11 +1213,15 @@ def handleNodeLoad(self, node):
                 # alias of other Importation and the alias
                 # is used, SubImportation also should be marked as used.
                 n = scope[name]
-                if isinstance(n, Importation) and n._has_alias():
-                    try:
-                        scope[n.fullName].used = (self.scope, node)
-                    except KeyError:
-                        pass
+                if isinstance(n, Importation):
+                    if n._has_alias():
+                        try:
+                            scope[n.fullName].used = (self.scope, node)
+                        except KeyError:
+                            pass
+                    if n.during_type_checking and not self._in_annotation:
+                        # Only defined during type-checking; this does not count.
+                        continue
             except KeyError:
                 pass
             else:
@@ -1973,7 +1979,12 @@ def DICT(self, node):
     def IF(self, node):
         if isinstance(node.test, ast.Tuple) and node.test.elts != []:
             self.report(messages.IfTuple, node)
+
+        prev = self._in_type_checking
+        if _is_typing(node.test, 'TYPE_CHECKING', self.scopeStack):
+            self._in_type_checking = True
         self.handleChildren(node)
+        self._in_type_checking = prev
 
     IFEXP = IF
 
@@ -2260,6 +2271,7 @@ def IMPORT(self, node):
             else:
                 name = alias.asname or alias.name
                 importation = Importation(name, node, alias.name)
+            importation.during_type_checking = self._in_type_checking
             self.addBinding(node, importation)
 
     def IMPORTFROM(self, node):
@@ -2294,6 +2306,7 @@ def IMPORTFROM(self, node):
             else:
                 importation = ImportationFrom(name, node,
                                               module, alias.name)
+            importation.during_type_checking = self._in_type_checking
             self.addBinding(node, importation)
 
     def TRY(self, node):

pyflakes/test/test_imports.py

@@ -1031,6 +1031,25 @@ def test_futureImportStar(self):
         from __future__ import *
         ''', m.FutureFeatureNotDefined)
 
+    def test_ignoresTypingImports(self):
+        """Ignores imports within 'if TYPE_CHECKING' checking normal code."""
+        self.flakes('''
+        from typing import TYPE_CHECKING
+        if TYPE_CHECKING:
+            from a import b
+        b()
+        ''', m.UndefinedName)
+
+    def test_usesTypingImportsForAnnotations(self):
+        """Uses imports within 'if TYPE_CHECKING' checking annotations."""
+        self.flakes('''
+        from typing import TYPE_CHECKING
+        if TYPE_CHECKING:
+            from a import b
+        def f() -> "b":
+            pass
+        ''')
+
 
 class TestSpecialAll(TestCase):
     """