add warning for unused global / nonlocal names

pyflakes/checker.py

@@ -543,6 +543,8 @@ def __init__(self):
         super().__init__()
         # Simplify: manage the special locals as globals
         self.globals = self.alwaysUsed.copy()
+        # {name: node}
+        self.indirect_assignments = {}
 
     def unused_assignments(self):
         """
@@ -564,6 +566,9 @@ def unused_annotations(self):
             if not binding.used and isinstance(binding, Annotation):
                 yield name, binding
 
+    def unused_indirect_assignments(self):
+        return self.indirect_assignments.items()
+
 
 class TypeScope(Scope):
     pass
@@ -839,6 +844,8 @@ def checkDeadScopes(self):
                     self.report(messages.UnusedVariable, binding.source, name)
                 for name, binding in scope.unused_annotations():
                     self.report(messages.UnusedAnnotation, binding.source, name)
+                for name, node in scope.unused_indirect_assignments():
+                    self.report(messages.UnusedIndirectAssignment, node, name)
 
             all_binding = scope.get('__all__')
             if all_binding and not isinstance(all_binding, ExportBinding):
@@ -981,6 +988,9 @@ def addBinding(self, node, value):
                     self.report(messages.RedefinedWhileUnused,
                                 node, value.name, existing.source)
 
+                if isinstance(scope, FunctionScope):
+                    scope.indirect_assignments.pop(value.name, None)
+
             elif isinstance(existing, Importation) and value.redefines(existing):
                 existing.redefined.append(node)
 
@@ -1177,6 +1187,9 @@ def on_conditional_branch():
             # be executed.
             return
 
+        if isinstance(self.scope, FunctionScope):
+            self.scope.indirect_assignments.pop(name, None)
+
         if isinstance(self.scope, FunctionScope) and name in self.scope.globals:
             self.scope.globals.remove(name)
         else:
@@ -1835,6 +1848,8 @@ def GLOBAL(self, node):
                 for scope in self.scopeStack[global_scope_index + 1:]:
                     scope[node_name] = node_value
 
+                self.scope.indirect_assignments[node_name] = node
+
     NONLOCAL = GLOBAL
 
     def GENERATOREXP(self, node):

pyflakes/messages.py

@@ -168,6 +168,15 @@ def __init__(self, filename, loc, names):
         self.message_args = (names,)
 
 
+class UnusedIndirectAssignment(Message):
+    """A `global` or `nonlocal` statement where the name is never reassigned"""
+    message = '`%s %s` is unused: name is never assigned in scope'
+
+    def __init__(self, filename, loc, name):
+        Message.__init__(self, filename, loc)
+        self.message_args = (type(loc).__name__.lower(), name)
+
+
 class ReturnOutsideFunction(Message):
     """
     Indicates a return statement outside of a function/method.

pyflakes/test/test_imports.py

@@ -654,7 +654,7 @@ def test_usedInGlobal(self):
         self.flakes('''
         import fu
         def f(): global fu
-        ''', m.UnusedImport)
+        ''', m.UnusedImport, m.UnusedIndirectAssignment)
 
     def test_usedAndGlobal(self):
         """
@@ -665,7 +665,7 @@ def test_usedAndGlobal(self):
             import foo
             def f(): global foo
             def g(): foo.is_used()
-        ''')
+        ''', m.UnusedIndirectAssignment)
 
     def test_assignedToGlobal(self):
         """

pyflakes/test/test_other.py

@@ -1085,7 +1085,41 @@ def test_globalDeclaredInDifferentScope(self):
         self.flakes('''
         def f(): global foo
         def g(): foo = 'anything'; foo.is_used()
-        ''')
+        ''', m.UnusedIndirectAssignment)
+
+    def test_unused_global_statement(self):
+        self.flakes('''
+        g = 0
+        def f1():
+            global g
+            g = 1
+        def f2():
+            global g  # this is unused!
+            return g
+        ''', m.UnusedIndirectAssignment)
+
+    def test_unused_nonlocal_statement(self):
+        self.flakes('''
+        def f():
+            x = 1
+            def set_x():
+                nonlocal x
+                x = 2
+            def get_x():
+                nonlocal x
+                return x
+            set_x()
+            return get_x()
+        ''', m.UnusedIndirectAssignment)
+
+    def test_unused_global_statement_not_marked_as_used_by_nested_scope(self):
+        self.flakes('''
+        g = 0
+        def f():
+            global g
+            def f2():
+                g = 2
+        ''', m.UnusedIndirectAssignment, m.UnusedVariable)
 
     def test_function_arguments(self):
         """

pyflakes/test/test_undefined_names.py

@@ -327,7 +327,7 @@ def f1():
 
         def f2():
             global m
-        ''', m.UndefinedName)
+        ''', m.UndefinedName, m.UnusedIndirectAssignment)
 
     @skip("todo")
     def test_unused_global(self):
@@ -462,7 +462,7 @@ def fun2():
                     a
                     a = 2
                     return a
-        ''', m.UndefinedLocal)
+        ''', m.UndefinedLocal, m.UnusedIndirectAssignment)
 
     def test_intermediateClassScopeIgnored(self):
         """