Rename to for_annotations

Author: PetterS

pyflakes/checker.py

@@ -321,12 +321,12 @@ class Binding(object):
                 the node that this binding was last used.
     """
 
-    def __init__(self, name, source, during_type_checking):
+    def __init__(self, name, source, for_annotations):
         self.name = name
         self.source = source
         self.used = False
-        assert isinstance(during_type_checking, bool)
-        self.during_type_checking = during_type_checking
+        assert isinstance(for_annotations, bool)
+        self.for_annotations = for_annotations
 
     def __str__(self):
         return self.name
@@ -351,7 +351,7 @@ class Builtin(Definition):
     """A definition created for all Python builtins."""
 
     def __init__(self, name):
-        super(Builtin, self).__init__(name, None, during_type_checking=False)
+        super(Builtin, self).__init__(name, None, for_annotations=False)
 
     def __repr__(self):
         return '<%s object %r at 0x%x>' % (self.__class__.__name__,
@@ -393,11 +393,11 @@ class Importation(Definition):
     @type fullName: C{str}
     """
 
-    def __init__(self, name, source, during_type_checking, full_name=None):
+    def __init__(self, name, source, for_annotations, full_name=None):
         self.fullName = full_name or name
         self.redefined = []
         super(Importation, self).__init__(name, source,
-                                          during_type_checking=during_type_checking)
+                                          for_annotations=for_annotations)
 
     def redefines(self, other):
         if isinstance(other, SubmoduleImportation):
@@ -442,12 +442,12 @@ class SubmoduleImportation(Importation):
     name is also the same, to avoid false positives.
     """
 
-    def __init__(self, name, source, during_type_checking):
+    def __init__(self, name, source, for_annotations):
         # A dot should only appear in the name when it is a submodule import
         assert '.' in name and (not source or isinstance(source, ast.Import))
         package_name = name.split('.')[0]
         super(SubmoduleImportation, self).__init__(
-            package_name, source, during_type_checking=during_type_checking)
+            package_name, source, for_annotations=for_annotations)
         self.fullName = name
 
     def redefines(self, other):
@@ -465,7 +465,7 @@ def source_statement(self):
 
 class ImportationFrom(Importation):
 
-    def __init__(self, name, source, module, during_type_checking, real_name=None):
+    def __init__(self, name, source, module, for_annotations, real_name=None):
         self.module = module
         self.real_name = real_name or name
 
@@ -475,7 +475,7 @@ def __init__(self, name, source, module, during_type_checking, real_name=None):
             full_name = module + '.' + self.real_name
 
         super(ImportationFrom, self).__init__(name, source, full_name=full_name,
-                                              during_type_checking=during_type_checking)
+                                              for_annotations=for_annotations)
 
     def __str__(self):
         """Return import full name with alias."""
@@ -497,9 +497,9 @@ def source_statement(self):
 class StarImportation(Importation):
     """A binding created by a 'from x import *' statement."""
 
-    def __init__(self, name, source, during_type_checking):
+    def __init__(self, name, source, for_annotations):
         super(StarImportation, self).__init__('*', source,
-                                              during_type_checking=during_type_checking)
+                                              for_annotations=for_annotations)
         # Each star importation needs a unique name, and
         # may not be the module name otherwise it will be deemed imported
         self.name = name + '.*'
@@ -526,7 +526,7 @@ class FutureImportation(ImportationFrom):
 
     def __init__(self, name, source, scope):
         super(FutureImportation, self).__init__(name, source, '__future__',
-                                                during_type_checking=False)
+                                                for_annotations=False)
         self.used = (scope, source)
 
 
@@ -535,7 +535,7 @@ class Argument(Binding):
     Represents binding a name as an argument.
     """
     def __init__(self, name, source):
-        super(Argument, self).__init__(name, source, during_type_checking=False)
+        super(Argument, self).__init__(name, source, for_annotations=False)
 
 
 class Assignment(Binding):
@@ -585,7 +585,7 @@ class ExportBinding(Binding):
     C{__all__} will not have an unused import warning reported for them.
     """
 
-    def __init__(self, name, source, scope, during_type_checking):
+    def __init__(self, name, source, scope, for_annotations):
         if '__all__' in scope and isinstance(source, ast.AugAssign):
             self.names = list(scope['__all__'].names)
         else:
@@ -616,7 +616,7 @@ def _add_to_names(container):
                 # If not list concatenation
                 else:
                     break
-        super(ExportBinding, self).__init__(name, source, during_type_checking)
+        super(ExportBinding, self).__init__(name, source, for_annotations)
 
 
 class Scope(dict):
@@ -1228,7 +1228,7 @@ def handleNodeLoad(self, node):
                         scope[n.fullName].used = (self.scope, node)
                     except KeyError:
                         pass
-                if n.during_type_checking and not self._in_annotation:
+                if n.for_annotations and not self._in_annotation:
                     # Only defined during type-checking; this does not count. Real code
                     # (not an annotation) using this binding will not work.
                     continue
@@ -1294,14 +1294,14 @@ def handleNodeStore(self, node):
         elif isinstance(parent_stmt, (FOR_TYPES, ast.comprehension)) or (
                 parent_stmt != node._pyflakes_parent and
                 not self.isLiteralTupleUnpacking(parent_stmt)):
-            binding = Binding(name, node, during_type_checking=self._in_type_checking)
+            binding = Binding(name, node, for_annotations=self._in_type_checking)
         elif name == '__all__' and isinstance(self.scope, ModuleScope):
             binding = ExportBinding(name, node._pyflakes_parent, self.scope,
-                                    during_type_checking=self._in_type_checking)
+                                    for_annotations=self._in_type_checking)
         elif PY2 and isinstance(getattr(node, 'ctx', None), ast.Param):
             binding = Argument(name, self.getScopeNode(node))
         else:
-            binding = Assignment(name, node, during_type_checking=self._in_type_checking)
+            binding = Assignment(name, node, for_annotations=self._in_type_checking)
         self.addBinding(node, binding)
 
     def handleNodeDelete(self, node):
@@ -2017,7 +2017,7 @@ def GLOBAL(self, node):
             # One 'global' statement can bind multiple (comma-delimited) names.
             for node_name in node.names:
                 node_value = Assignment(node_name, node,
-                                        during_type_checking=self._in_type_checking)
+                                        for_annotations=self._in_type_checking)
 
                 # Remove UndefinedName messages already reported for this name.
                 # TODO: if the global is not used in this scope, it does not
@@ -2120,7 +2120,7 @@ def FUNCTIONDEF(self, node):
             self.handleNode(deco, node)
         self.LAMBDA(node)
         self.addBinding(node, FunctionDefinition(
-            node.name, node, during_type_checking=self._in_type_checking))
+            node.name, node, for_annotations=self._in_type_checking))
         # doctest does not process doctest within a doctest,
         # or in nested functions.
         if (self.withDoctest and
@@ -2246,7 +2246,7 @@ def CLASSDEF(self, node):
             self.handleNode(stmt, node)
         self.popScope()
         self.addBinding(node, ClassDefinition(
-            node.name, node, during_type_checking=self._in_type_checking))
+            node.name, node, for_annotations=self._in_type_checking))
 
     def AUGASSIGN(self, node):
         self.handleNodeLoad(node.target)
@@ -2282,11 +2282,11 @@ def IMPORT(self, node):
         for alias in node.names:
             if '.' in alias.name and not alias.asname:
                 importation = SubmoduleImportation(
-                    alias.name, node, during_type_checking=self._in_type_checking)
+                    alias.name, node, for_annotations=self._in_type_checking)
             else:
                 name = alias.asname or alias.name
                 importation = Importation(name, node, full_name=alias.name,
-                                          during_type_checking=self._in_type_checking)
+                                          for_annotations=self._in_type_checking)
             self.addBinding(node, importation)
 
     def IMPORTFROM(self, node):
@@ -2317,11 +2317,11 @@ def IMPORTFROM(self, node):
                 self.scope.importStarred = True
                 self.report(messages.ImportStarUsed, node, module)
                 importation = StarImportation(
-                    module, node, during_type_checking=self._in_type_checking)
+                    module, node, for_annotations=self._in_type_checking)
             else:
                 importation = ImportationFrom(
                     name, node, module, real_name=alias.name,
-                    during_type_checking=self._in_type_checking)
+                    for_annotations=self._in_type_checking)
             self.addBinding(node, importation)
 
     def TRY(self, node):

pyflakes/test/test_imports.py

@@ -14,86 +14,86 @@
 class TestImportationObject(TestCase):
 
     def test_import_basic(self):
-        binding = Importation('a', None, during_type_checking=False, full_name='a')
+        binding = Importation('a', None, for_annotations=False, full_name='a')
         assert binding.source_statement == 'import a'
         assert str(binding) == 'a'
 
     def test_import_as(self):
-        binding = Importation('c', None, during_type_checking=False, full_name='a')
+        binding = Importation('c', None, for_annotations=False, full_name='a')
         assert binding.source_statement == 'import a as c'
         assert str(binding) == 'a as c'
 
     def test_import_submodule(self):
-        binding = SubmoduleImportation('a.b', None, during_type_checking=False)
+        binding = SubmoduleImportation('a.b', None, for_annotations=False)
         assert binding.source_statement == 'import a.b'
         assert str(binding) == 'a.b'
 
     def test_import_submodule_as(self):
         # A submodule import with an as clause is not a SubmoduleImportation
-        binding = Importation('c', None, during_type_checking=False, full_name='a.b')
+        binding = Importation('c', None, for_annotations=False, full_name='a.b')
         assert binding.source_statement == 'import a.b as c'
         assert str(binding) == 'a.b as c'
 
     def test_import_submodule_as_source_name(self):
-        binding = Importation('a', None, during_type_checking=False, full_name='a.b')
+        binding = Importation('a', None, for_annotations=False, full_name='a.b')
         assert binding.source_statement == 'import a.b as a'
         assert str(binding) == 'a.b as a'
 
     def test_importfrom_relative(self):
         binding = ImportationFrom('a', None, '.',
-                                  during_type_checking=False, real_name='a')
+                                  for_annotations=False, real_name='a')
         assert binding.source_statement == 'from . import a'
         assert str(binding) == '.a'
 
     def test_importfrom_relative_parent(self):
         binding = ImportationFrom('a', None, '..',
-                                  during_type_checking=False, real_name='a')
+                                  for_annotations=False, real_name='a')
         assert binding.source_statement == 'from .. import a'
         assert str(binding) == '..a'
 
     def test_importfrom_relative_with_module(self):
         binding = ImportationFrom('b', None, '..a',
-                                  during_type_checking=False, real_name='b')
+                                  for_annotations=False, real_name='b')
         assert binding.source_statement == 'from ..a import b'
         assert str(binding) == '..a.b'
 
     def test_importfrom_relative_with_module_as(self):
         binding = ImportationFrom('c', None, '..a',
-                                  during_type_checking=False, real_name='b')
+                                  for_annotations=False, real_name='b')
         assert binding.source_statement == 'from ..a import b as c'
         assert str(binding) == '..a.b as c'
 
     def test_importfrom_member(self):
         binding = ImportationFrom('b', None, 'a',
-                                  during_type_checking=False, real_name='b')
+                                  for_annotations=False, real_name='b')
         assert binding.source_statement == 'from a import b'
         assert str(binding) == 'a.b'
 
     def test_importfrom_submodule_member(self):
         binding = ImportationFrom('c', None, 'a.b',
-                                  during_type_checking=False, real_name='c')
+                                  for_annotations=False, real_name='c')
         assert binding.source_statement == 'from a.b import c'
         assert str(binding) == 'a.b.c'
 
     def test_importfrom_member_as(self):
         binding = ImportationFrom('c', None, 'a',
-                                  during_type_checking=False, real_name='b')
+                                  for_annotations=False, real_name='b')
         assert binding.source_statement == 'from a import b as c'
         assert str(binding) == 'a.b as c'
 
     def test_importfrom_submodule_member_as(self):
         binding = ImportationFrom('d', None, 'a.b',
-                                  during_type_checking=False, real_name='c')
+                                  for_annotations=False, real_name='c')
         assert binding.source_statement == 'from a.b import c as d'
         assert str(binding) == 'a.b.c as d'
 
     def test_importfrom_star(self):
-        binding = StarImportation('a.b', None, during_type_checking=False)
+        binding = StarImportation('a.b', None, for_annotations=False)
         assert binding.source_statement == 'from a.b import *'
         assert str(binding) == 'a.b.*'
 
     def test_importfrom_star_relative(self):
-        binding = StarImportation('.b', None, during_type_checking=False)
+        binding = StarImportation('.b', None, for_annotations=False)
         assert binding.source_statement == 'from .b import *'
         assert str(binding) == '.b.*'