Fix false positives for 'unnecessary-dunder-call' in lambdas (#9034)

* Add exceptions to C2801 for certain dunders in a lambda definition

* Split tests based on implementation and version to pass checks and have finer control

Author: badsketch

doc/whatsnew/fragments/8769.bugfix

@@ -0,0 +1,3 @@
+Dunder methods defined in lambda do not trigger ``unnecessary-dunder-call`` anymore, if they cannot be replaced by the non-dunder call.
+
+Closes #8769

pylint/checkers/dunder_methods.py

@@ -11,7 +11,7 @@
 
 from pylint.checkers import BaseChecker
 from pylint.checkers.utils import safe_infer
-from pylint.constants import DUNDER_METHODS
+from pylint.constants import DUNDER_METHODS, UNNECESSARY_DUNDER_CALL_LAMBDA_EXCEPTIONS
 from pylint.interfaces import HIGH
 
 if TYPE_CHECKING:
@@ -52,25 +52,33 @@ def open(self) -> None:
                 self._dunder_methods.update(dunder_methods)
 
     @staticmethod
-    def within_dunder_def(node: nodes.NodeNG) -> bool:
+    def within_dunder_or_lambda_def(node: nodes.NodeNG) -> bool:
         """Check if dunder method call is within a dunder method definition."""
         parent = node.parent
         while parent is not None:
             if (
                 isinstance(parent, nodes.FunctionDef)
                 and parent.name.startswith("__")
                 and parent.name.endswith("__")
+                or DunderCallChecker.is_lambda_rule_exception(parent, node)
             ):
                 return True
             parent = parent.parent
         return False
 
+    @staticmethod
+    def is_lambda_rule_exception(ancestor: nodes.NodeNG, node: nodes.NodeNG) -> bool:
+        return (
+            isinstance(ancestor, nodes.Lambda)
+            and node.func.attrname in UNNECESSARY_DUNDER_CALL_LAMBDA_EXCEPTIONS
+        )
+
     def visit_call(self, node: nodes.Call) -> None:
         """Check if method being called is an unnecessary dunder method."""
         if (
             isinstance(node.func, nodes.Attribute)
             and node.func.attrname in self._dunder_methods
-            and not self.within_dunder_def(node)
+            and not self.within_dunder_or_lambda_def(node)
             and not (
                 isinstance(node.func.expr, nodes.Call)
                 and isinstance(node.func.expr.func, nodes.Name)

pylint/constants.py

@@ -249,3 +249,28 @@ def _get_pylint_home() -> str:
     "__subclasshook__",
     "__weakref__",
 ]
+
+# C2801 rule exceptions as their corresponding function/method/operator
+# is not valid python syntax in a lambda definition
+UNNECESSARY_DUNDER_CALL_LAMBDA_EXCEPTIONS = [
+    "__init__",
+    "__del__",
+    "__delattr__",
+    "__set__",
+    "__delete__",
+    "__setitem__",
+    "__delitem__",
+    "__iadd__",
+    "__isub__",
+    "__imul__",
+    "__imatmul__",
+    "__itruediv__",
+    "__ifloordiv__",
+    "__imod__",
+    "__ipow__",
+    "__ilshift__",
+    "__irshift__",
+    "__iand__",
+    "__ixor__",
+    "__ior__",
+]

tests/functional/u/unnecessary/unnecessary_dunder_call.txt

@@ -1,6 +1,7 @@
 """Checks for unnecessary-dunder-call."""
 # pylint: disable=too-few-public-methods, undefined-variable
 # pylint: disable=missing-class-docstring, missing-function-docstring
+# pylint: disable=protected-access, unnecessary-lambda-assignment, unnecessary-lambda
 from collections import OrderedDict
 from typing import Any
 
@@ -128,3 +129,16 @@ class MyString(str):
     def rjust(self, width, fillchar= ' '):
         """Acceptable call to __index__"""
         width = width.__index__()
+
+# Test no lint raised for these dunders within lambdas
+lambda1 = lambda x: x.__setitem__(1,2)
+lambda2 = lambda x: x.__del__(1)
+lambda3 = lambda x,y: x.__ipow__(y)
+lambda4 = lambda u,v: u.__setitem__(v())
+
+# Test lint raised for these dunders within lambdas
+lambda5 = lambda x: x.__gt__(3) # [unnecessary-dunder-call]
+lambda6 = lambda x,y: x.__or__(y) # [unnecessary-dunder-call]
+lambda7 = lambda x: x.__iter__() # [unnecessary-dunder-call]
+lambda8 = lambda z: z.__hash__() # [unnecessary-dunder-call]
+lambda9 = lambda n: (4).__rmul__(n) # [unnecessary-dunder-call]

tests/functional/u/unnecessary/unnecessary_dunder_call.py renamed to tests/functional/u/unnecessary/unnecessary_dunder_call_py38.py

@@ -0,0 +1,3 @@
+[testoptions]
+max_pyver=3.8
+except_implementations=PyPy

tests/functional/u/unnecessary/unnecessary_dunder_call_py38.rc

@@ -0,0 +1,13 @@
+unnecessary-dunder-call:9:10:9:28::Unnecessarily calls dunder method __str__. Use str built-in function.:HIGH
+unnecessary-dunder-call:10:11:10:30::Unnecessarily calls dunder method __add__. Use + operator.:HIGH
+unnecessary-dunder-call:11:10:11:40::Unnecessarily calls dunder method __repr__. Use repr built-in function.:HIGH
+unnecessary-dunder-call:13:18:13:43::Unnecessarily calls dunder method __contains__. Use in keyword.:HIGH
+unnecessary-dunder-call:18:0:18:31::Unnecessarily calls dunder method __init__. Instantiate class directly.:HIGH
+unnecessary-dunder-call:26:11:26:24:is_bigger_than_two:Unnecessarily calls dunder method __gt__. Use > operator.:HIGH
+unnecessary-dunder-call:119:20:119:39::Unnecessarily calls dunder method __add__. Use + operator.:HIGH
+unnecessary-dunder-call:120:0:120:44::Unnecessarily calls dunder method __setitem__. Set item via subscript.:HIGH
+unnecessary-dunder-call:140:20:140:31:<lambda>:Unnecessarily calls dunder method __gt__. Use > operator.:HIGH
+unnecessary-dunder-call:141:22:141:33:<lambda>:Unnecessarily calls dunder method __or__. Use | operator.:HIGH
+unnecessary-dunder-call:142:20:142:32:<lambda>:Unnecessarily calls dunder method __iter__. Use iter built-in function.:HIGH
+unnecessary-dunder-call:143:20:143:32:<lambda>:Unnecessarily calls dunder method __hash__. Use hash built-in function.:HIGH
+unnecessary-dunder-call:144:20:144:35:<lambda>:Unnecessarily calls dunder method __rmul__. Use * operator.:HIGH

tests/functional/u/unnecessary/unnecessary_dunder_call_py38.txt

@@ -0,0 +1,144 @@
+"""Checks for unnecessary-dunder-call."""
+# pylint: disable=too-few-public-methods, undefined-variable
+# pylint: disable=missing-class-docstring, missing-function-docstring
+# pylint: disable=protected-access, unnecessary-lambda-assignment, unnecessary-lambda
+from collections import OrderedDict
+from typing import Any
+
+# Test includelisted dunder methods raise lint when manually called.
+num_str = some_num.__str__() # [unnecessary-dunder-call]
+num_repr = some_num.__add__(2) # [unnecessary-dunder-call]
+my_repr = my_module.my_object.__repr__() # [unnecessary-dunder-call]
+
+MY_CONTAINS_BAD = {1, 2, 3}.__contains__(1) # [unnecessary-dunder-call]
+MY_CONTAINS_GOOD = 1 in {1, 2, 3}
+
+# Just instantiate like a normal person please
+my_list_bad = []
+my_list_bad.__init__({1, 2, 3}) # [unnecessary-dunder-call]
+my_list_good = list({1, 2, 3})
+
+# Test unknown/user-defined dunder methods don't raise lint.
+my_woohoo = my_object.__woohoo__()
+
+# Test lint raised within function.
+def is_bigger_than_two(val):
+    return val.__gt__(2)  # [unnecessary-dunder-call]
+
+# Test dunder methods don't raise lint
+# if within a dunder method definition.
+class Foo1:
+    def __init__(self):
+        object.__init__(self)
+
+class Foo2:
+    def __init__(self):
+        super().__init__(self)
+
+class Bar1:
+    def __new__(cls):
+        object.__new__(cls)
+
+class Bar2:
+    def __new__(cls):
+        super().__new__(cls)
+
+class CustomRegistry(dict):
+    def __init__(self) -> None:
+        super().__init__()
+        self._entry_ids = {}
+
+    def __setitem__(self, key, entry) -> None:
+        super().__setitem__(key, entry)
+        self._entry_ids.__setitem__(entry.id, entry)
+        self._entry_ids.__delitem__(entry.id)
+
+    def __delitem__(self, key: str) -> None:
+        entry = self[key]
+        self._entry_ids.__delitem__(entry.id)
+        super().__delitem__(key)
+
+class CustomState:
+    def __init__(self, state):
+        self._state = state
+
+    def __eq__(self, other: Any) -> bool:
+        return self._state.__eq__(other)
+
+class CustomDict(OrderedDict):
+    def __init__(self, *args, **kwds):
+        OrderedDict.__init__(self, *args, **kwds)
+
+    def __setitem__(self, key, value):
+        OrderedDict.__setitem__(self, key, value)
+
+
+class MyClass(list):
+    def __contains__(self, item):
+        print("do some special checks")
+        return super().__contains__(item)
+
+class PluginBase:
+    subclasses = []
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls.subclasses.append(cls)
+
+# Validate that dunder call is allowed
+# at any depth within dunder definition
+class SomeClass:
+    def __init__(self):
+        self.my_attr = object()
+
+    def __setattr__(self, name, value):
+        def nested_function():
+            self.my_attr.__setattr__(name, value)
+
+        nested_function()
+
+# Allow use of dunder methods that don't
+# have an alternate method of being called
+class Base:
+    @classmethod
+    def get_first_subclass(cls):
+        for subklass in cls.__subclasses__():
+            return subklass
+        return object
+
+# Test no lint raised for attributes.
+my_instance_name = x.__class__.__name__
+my_pkg_version = pkg.__version__
+
+# Allow use of dunder methods on non instantiated classes
+MANUAL_SELF = int.__add__(1, 1)
+MY_DICT = {"a": 1, "b": 2}
+dict.__setitem__(MY_DICT, "key", "value")
+
+# Still flag instantiated classes
+INSTANTIATED_SELF = int("1").__add__(1) # [unnecessary-dunder-call]
+{"a": 1, "b": 2}.__setitem__("key", "value") # [unnecessary-dunder-call]
+
+# We also exclude dunder methods called on super
+# since we can't apply alternate operators/functions here.
+a = [1, 2, 3]
+assert super(type(a), a).__str__() == "[1, 2, 3]"
+
+class MyString(str):
+    """Custom str implementation"""
+    def rjust(self, width, fillchar= ' '):
+        """Acceptable call to __index__"""
+        width = width.__index__()
+
+# Test no lint raised for these dunders within lambdas
+lambda1 = lambda x: x.__setitem__(1,2)
+lambda2 = lambda x: x.__del__(1)
+lambda3 = lambda x,y: x.__ipow__(y)
+lambda4 = lambda u,v: u.__setitem__(v())
+
+# Test lint raised for these dunders within lambdas
+lambda5 = lambda x: x.__gt__(3) # [unnecessary-dunder-call]
+lambda6 = lambda x,y: x.__or__(y) # [unnecessary-dunder-call]
+lambda7 = lambda x: x.__iter__() # [unnecessary-dunder-call]
+lambda8 = lambda z: z.__hash__() # [unnecessary-dunder-call]
+lambda9 = lambda n: (4).__rmul__(n) # [unnecessary-dunder-call]

tests/functional/u/unnecessary/unnecessary_dunder_call_py38_pypy.py

@@ -0,0 +1,3 @@
+[testoptions]
+max_pyver=3.8
+except_implementations=CPython

tests/functional/u/unnecessary/unnecessary_dunder_call_py38_pypy.rc

@@ -0,0 +1,13 @@
+unnecessary-dunder-call:9:10:None:None::Unnecessarily calls dunder method __str__. Use str built-in function.:HIGH
+unnecessary-dunder-call:10:11:None:None::Unnecessarily calls dunder method __add__. Use + operator.:HIGH
+unnecessary-dunder-call:11:10:None:None::Unnecessarily calls dunder method __repr__. Use repr built-in function.:HIGH
+unnecessary-dunder-call:13:18:None:None::Unnecessarily calls dunder method __contains__. Use in keyword.:HIGH
+unnecessary-dunder-call:18:0:None:None::Unnecessarily calls dunder method __init__. Instantiate class directly.:HIGH
+unnecessary-dunder-call:26:11:None:None:is_bigger_than_two:Unnecessarily calls dunder method __gt__. Use > operator.:HIGH
+unnecessary-dunder-call:119:20:None:None::Unnecessarily calls dunder method __add__. Use + operator.:HIGH
+unnecessary-dunder-call:120:0:None:None::Unnecessarily calls dunder method __setitem__. Set item via subscript.:HIGH
+unnecessary-dunder-call:140:20:None:None:<lambda>:Unnecessarily calls dunder method __gt__. Use > operator.:HIGH
+unnecessary-dunder-call:141:22:None:None:<lambda>:Unnecessarily calls dunder method __or__. Use | operator.:HIGH
+unnecessary-dunder-call:142:20:None:None:<lambda>:Unnecessarily calls dunder method __iter__. Use iter built-in function.:HIGH
+unnecessary-dunder-call:143:20:None:None:<lambda>:Unnecessarily calls dunder method __hash__. Use hash built-in function.:HIGH
+unnecessary-dunder-call:144:21:None:None:<lambda>:Unnecessarily calls dunder method __rmul__. Use * operator.:HIGH