Merge pull request #199 from asottile/typeddict

add workaround for AnnAssign in class bodies

Author: asottile

dead.py

@@ -99,6 +99,20 @@ def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
     def visit_ClassDef(self, node: ast.ClassDef) -> None:
         self.define(node.name, node)
         self.generic_visit(node)
+        # this is a bad middle ground to handle TypedDict and related classes
+        # simply mark any annotated assignment directly in a class body as
+        # "used"
+        # *ideally* with full semantic analysis you'd be able to know when
+        # a dictionary literal uses the same key as a specific TypedDict
+        # and know if it is used.  unfortunately it's difficult to know
+        # statically in isolation whether a class definition is a TypedDict
+        # due to inheritance (and multiple inheritance (and module boundaries))
+        for stmt in node.body:
+            if (
+                    isinstance(stmt, ast.AnnAssign) and
+                    isinstance(stmt.target, ast.Name)
+            ):
+                self.read(stmt.target.id, stmt)
 
     def _is_stub_function(self, node: FunctionDef) -> bool:
         for stmt in node.body:

tests/dead_test.py

@@ -276,6 +276,35 @@ def test_unused_annotated_assignment(git_dir, capsys):
     assert out == 'SOME_CONSTANT is never read, defined in f.py:2\n'
 
 
+def test_typedict_keys_used(git_dir, capsys):
+    src = '''\
+from typing import TypedDict
+
+class T(TypedDict):
+    foo: str
+    bar: str
+
+
+def f() -> T:
+    return {
+        "foo": "str1",
+        "bar": "str2",
+    }
+
+
+def g() -> None:
+    f = f()
+    print(f["foo"])
+    print(f["bar"])
+
+
+g()
+'''
+    git_dir.join('f.py').write(src)
+    subprocess.check_call(('git', 'add', '.'))
+    assert not dead.main(())
+
+
 def test_allowed_symbols_file(git_dir, tmp_path, capsys):
     allowed = tmp_path.joinpath('allowed')
     allowed.write_text('unused_function\n')