Detect unused annotations in functions

pyflakes/checker.py

@@ -600,6 +600,17 @@ def unusedAssignments(self):
                     isinstance(binding, Assignment)):
                 yield name, binding
 
+    def unusedAnnotations(self):
+        """
+        Return a generator for the annotations which have not been used.
+        """
+        for name, binding in self.items():
+            if (not binding.used and
+                    name not in self.globals and
+                    not self.usesLocals and
+                    isinstance(binding, Annotation)):
+                yield name, binding
+
 
 class GeneratorScope(Scope):
     pass
@@ -1156,6 +1167,7 @@ def handleNodeLoad(self, node):
 
             binding = scope.get(name, None)
             if isinstance(binding, Annotation) and not self._in_postponed_annotation:
+                scope[name].used = True
                 continue
 
             if name == 'print' and isinstance(binding, Builtin):
@@ -2090,7 +2102,16 @@ def checkUnusedAssignments():
                 """
                 for name, binding in self.scope.unusedAssignments():
                     self.report(messages.UnusedVariable, binding.source, name)
+
+            def checkUnusedAnnotations():
+                """
+                Check to see if any annotations have not been used.
+                """
+                for name, binding in self.scope.unusedAnnotations():
+                    self.report(messages.UnusedAnnotation, binding.source, name)
+
             self.deferAssignment(checkUnusedAssignments)
+            self.deferAssignment(checkUnusedAnnotations)
 
             self.popScope()
 

pyflakes/messages.py

@@ -156,6 +156,25 @@ def __init__(self, filename, loc, names):
         self.message_args = (names,)
 
 
+class UnusedAnnotation(Message):
+    """
+    Indicates that a variable has been explicitly annotated to but not actually
+    used.
+    """
+    message = 'local variable %r is annotated but never used'
+
+    def __init__(self, filename, loc, names):
+        Message.__init__(self, filename, loc)
+        self.message_args = (names,)
+
+
+class ReturnWithArgsInsideGenerator(Message):
+    """
+    Indicates a return statement with arguments inside a generator.
+    """
+    message = '\'return\' with argument inside generator'
+
+
 class ReturnOutsideFunction(Message):
     """
     Indicates a return statement outside of a function/method.

pyflakes/test/test_type_annotations.py

@@ -174,7 +174,7 @@ class C:
         def f():
             name: str
             age: int
-        ''')
+        ''', m.UnusedAnnotation, m.UnusedAnnotation)
         self.flakes('''
         def f():
             name: str = 'Bob'
@@ -190,7 +190,7 @@ def f():
         from typing import Any
         def f():
             a: Any
-        ''')
+        ''', m.UnusedAnnotation)
         self.flakes('''
         foo: not_a_real_type
         ''', m.UndefinedName)
@@ -356,18 +356,24 @@ def test_unused_annotation(self):
         class Cls:
             y: int
         ''')
-        # TODO: this should print a UnusedVariable message
+        # This should print an UnusedAnnotation message
         self.flakes('''
         def f():
             x: int
-        ''')
+        ''', m.UnusedAnnotation)
         # This should only print one UnusedVariable message
         self.flakes('''
         def f():
             x: int
             x = 3
         ''', m.UnusedVariable)
 
+    def test_unassigned_annotation_is_undefined(self):
+        self.flakes('''
+        name: str
+        print(name)
+        ''', m.UndefinedName)
+
     def test_annotated_async_def(self):
         self.flakes('''
         class c: pass