Make self-cls-assignment consider tuple assign. & ignore typing.cast()

ChangeLog

@@ -127,6 +127,9 @@ Release date: TBA
 
   Closes #4426
 
+* ``self-cls-assignment`` now also considers tuple assignment and does not raise a false positive on
+  ``typing.cast()``
+
 * Fix ``missing-function-docstring`` not being able to check ``__init__`` and other
   magic methods even if the ``no-docstring-rgx`` setting was set to do so
 

doc/whatsnew/2.12.rst

@@ -108,6 +108,9 @@ Other Changes
 
   Fixes part of #3688
 
+* ``self-cls-assignment`` now also considers tuple assignment and does not raise a false positive on
+  ``typing.cast()``
+
 * ``undefined-variable`` now correctly triggers for assignment expressions in if ... else statements
   This includes a basic form of control flow inference for if ... else statements using
   constant boolean values

pylint/checkers/variables.py

@@ -145,6 +145,7 @@
         "BinaryIO",
     }
 )
+NON_REASSIGNING_CALLS = {"typing.cast"}
 
 
 def _is_from_future_import(stmt, name):
@@ -2024,16 +2025,19 @@ def _store_type_annotation_names(self, node):
 
     def _check_self_cls_assign(self, node):
         """Check that self/cls don't get assigned"""
-        assign_names = {
-            target.name
-            for target in node.targets
-            if isinstance(target, nodes.AssignName)
-        }
+        assign_names = []
+        for target in node.targets:
+            if isinstance(target, nodes.AssignName):
+                assign_names.append(target.name)
+            elif isinstance(target, nodes.Tuple):
+                assign_names.extend(
+                    elt.name for elt in target.elts if isinstance(elt, nodes.AssignName)
+                )
         scope = node.scope()
         nonlocals_with_same_name = any(
             child
             for child in scope.body
-            if isinstance(child, nodes.Nonlocal) and assign_names & set(child.names)
+            if isinstance(child, nodes.Nonlocal) and assign_names + child.names
         )
         if nonlocals_with_same_name:
             scope = node.scope().parent.scope()
@@ -2048,12 +2052,18 @@ def _check_self_cls_assign(self, node):
         if not argument_names:
             return
         self_cls_name = argument_names[0]
-        target_assign_names = (
-            target.name
-            for target in node.targets
-            if isinstance(target, nodes.AssignName)
-        )
-        if self_cls_name in target_assign_names:
+        if self_cls_name in assign_names:
+            if isinstance(node.value, nodes.Call):
+                if utils.safe_infer(node.value.func).qname() in NON_REASSIGNING_CALLS:
+                    return
+            elif isinstance(node.value, nodes.Tuple):
+                index = assign_names.index(self_cls_name)
+                if (
+                    isinstance(node.value.elts[index], nodes.Call)
+                    and utils.safe_infer(node.value.elts[index].func).qname()
+                    in NON_REASSIGNING_CALLS
+                ):
+                    return
             self.add_message("self-cls-assignment", node=node, args=(self_cls_name,))
 
     def _check_unpacking(self, inferred, node, targets):

tests/functional/s/self/self_cls_assignment.py

@@ -1,5 +1,8 @@
 """Warning about assigning self/cls variable."""
 from __future__ import print_function
+
+from typing import cast
+
 # pylint: disable=too-few-public-methods, useless-object-inheritance
 
 class Foo(object):
@@ -14,6 +17,8 @@ def self_foo(bar_):
     def self_foofoo(self, lala):
         """Instance method, should warn for self"""
         self = lala  # [self-cls-assignment]
+        self, var = lala, 1  # [self-cls-assignment]
+        print(var)
 
     @classmethod
     def cls_foo(cls):
@@ -45,3 +50,14 @@ def _set_param(param):
 
         _set_param(param)
         return self
+
+
+class TestTypingCast:
+    """Test class for use of typing.cast"""
+
+    def function(self):
+        """This function uses typing.cast to reassign self"""
+
+        self = cast(TestTypingCast, self)
+        self, var = cast(TestTypingCast, self), 1
+        print(var)

tests/functional/s/self/self_cls_assignment.txt

@@ -1,4 +1,5 @@
-self-cls-assignment:11:8:Foo.self_foo:Invalid assignment to bar_ in method
-self-cls-assignment:16:8:Foo.self_foofoo:Invalid assignment to self in method
-self-cls-assignment:21:8:Foo.cls_foo:Invalid assignment to cls in method
-self-cls-assignment:44:12:TestNonLocal.function._set_param:Invalid assignment to self in method
+self-cls-assignment:14:8:Foo.self_foo:Invalid assignment to bar_ in method:HIGH
+self-cls-assignment:19:8:Foo.self_foofoo:Invalid assignment to self in method:HIGH
+self-cls-assignment:20:8:Foo.self_foofoo:Invalid assignment to self in method:HIGH
+self-cls-assignment:26:8:Foo.cls_foo:Invalid assignment to cls in method:HIGH
+self-cls-assignment:49:12:TestNonLocal.function._set_param:Invalid assignment to self in method:HIGH