Merge pull request nhoad#16 from joaoe/ignore_dunder

Ignore dunder methods

Author: nhoad

README.md

@@ -15,7 +15,11 @@ Configuration options also exist:
  - `unused-arguments-ignore-nested-functions` - don't show warnings for nested
    functions. Only show warnings for functions in the top level of a module, or methods
    of a class in the top level of a module.
-
+ - `unused-arguments-ignore-dunder` - don't show warnings for double-underscore methods.
+   These methods implement or override native builtin methods which have a specific
+   signature. Therefore arguments must always be present. This is the case of methods
+   like `__new__`, `__init__`, `__getitem__`, `__setitem__`, `__reduce_ex__`,
+   `__enter__`, `__exit__`, etc.
 
 ## Changelog
 

flake8_unused_arguments.py

@@ -19,6 +19,7 @@ class Plugin:
     ignore_variadic_names = False
     ignore_lambdas = False
     ignore_nested_functions = False
+    ignore_dunder_methods = False
 
     def __init__(self, tree: ast.Module):
         self.tree = tree
@@ -73,13 +74,26 @@ def add_options(cls, option_manager: flake8.options.manager.OptionManager) -> No
             ),
         )
 
+        option_manager.add_option(
+            "--unused-arguments-ignore-dunder",
+            action="store_true",
+            parse_from_config=True,
+            default=cls.ignore_dunder_methods,
+            dest="unused_arguments_ignore_dunder_methods",
+            help=(
+                "If provided, all double-underscore methods are ignored, e.g., __new__, _init__, "
+                "__enter__, __exit__, __reduce_ex__, etc.",
+            ),
+        )
+
     @classmethod
     def parse_options(cls, options: optparse.Values) -> None:
         cls.ignore_abstract = options.unused_arguments_ignore_abstract_functions
         cls.ignore_stubs = options.unused_arguments_ignore_stub_functions
         cls.ignore_variadic_names = options.unused_arguments_ignore_variadic_names
         cls.ignore_lambdas = options.unused_arguments_ignore_lambdas
         cls.ignore_nested_functions = options.unused_arguments_ignore_nested_functions
+        cls.ignore_dunder_methods = options.unused_arguments_ignore_dunder_methods
 
     def run(self) -> Iterable[LintResult]:
         finder = FunctionFinder(self.ignore_nested_functions)
@@ -99,6 +113,10 @@ def run(self) -> Iterable[LintResult]:
             if self.ignore_lambdas and isinstance(function, ast.Lambda):
                 continue
 
+            # ignore __double_underscore_methods__()
+            if self.ignore_dunder_methods and is_dunder_method(function):
+                continue
+
             for i, argument in get_unused_arguments(function):
                 name = argument.arg
                 if self.ignore_variadic_names:
@@ -224,6 +242,13 @@ def is_stub_function(function: FunctionTypes) -> bool:
     return False
 
 
+def is_dunder_method(function: FunctionTypes) -> bool:
+    if isinstance(function, ast.Lambda):
+        return False
+    name = function.name
+    return name and len(name) > 4 and name.startswith("__") and name.endswith("__")
+
+
 class FunctionFinder(NodeVisitor):
     functions: List[FunctionTypes]
 

test_unused_arguments.py

@@ -262,6 +262,48 @@ def bar(b):
                 (5, 13, "U100 Unused argument 'c'", "unused argument"),
             ],
         ),
+        (
+            """
+            class Foo:
+                def __new__(cls):
+                    return []
+                def __enter__(self):
+                    return self
+                def __exit__(self, exc_tp, exc_v, exc_tb):
+                    return False
+                def __setattr__(self, item, value):
+                    raise ValueError("read-only")
+                def __reduce_ex__(self, protocol):
+                    return Foo, ()
+            """,
+            {"ignore_dunder_methods": False},
+            [
+                (3, 16, "U100 Unused argument 'cls'", "unused argument"),
+                (7, 23, "U100 Unused argument 'exc_tp'", "unused argument"),
+                (7, 31, "U100 Unused argument 'exc_v'", "unused argument"),
+                (7, 38, "U100 Unused argument 'exc_tb'", "unused argument"),
+                (9, 26, "U100 Unused argument 'item'", "unused argument"),
+                (9, 32, "U100 Unused argument 'value'", "unused argument"),
+                (11, 28, "U100 Unused argument 'protocol'", "unused argument"),
+            ],
+        ),
+        (
+            """
+            class Foo:
+                def __new__(cls):
+                    return []
+                def __enter__(self):
+                    return self
+                def __exit__(self, exc_tp, exc_v, exc_tb):
+                    return False
+                def __setattr__(self, item, value):
+                    raise ValueError("read-only")
+                def __reduce_ex__(self, protocol):
+                    return Foo, ()
+            """,
+            {"ignore_dunder_methods": True},
+            [],
+        ),
         (
             """
     def foo(_a):