[pylint] Implement self-cls-assignment (W0642)

crates/ruff_linter/resources/test/fixtures/pylint/self_cls_assignment.py

@@ -0,0 +1,18 @@
+class Fruit:
+    @classmethod
+    def list_fruits(cls) -> None:
+        cls = "apple"  # PLW0642
+        cls: Fruit = "apple"  # PLW0642
+        cls += "orange"  # PLW0642
+        cls, blah = "apple", "orange"  # PLW0642
+        blah, (cls, blah2) = "apple", ("orange", "banana")  # PLW0642
+
+    def print_color(self) -> None:
+        self = "red"  # PLW0642
+        self: Self = "red"  # PLW0642
+        self += "blue"  # PLW0642
+        self, blah = "red", "blue"  # PLW0642
+        blah, (self, blah2) = "apple", ("orange", "banana")  # PLW0642
+
+    def ok(self) -> None:
+        cls = None  # OK because the rule looks for the name in the signature

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -1055,6 +1055,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             }
         }
         Stmt::AugAssign(aug_assign @ ast::StmtAugAssign { target, .. }) => {
+            if checker.enabled(Rule::SelfClsAssignment) {
+                pylint::rules::self_cls_assignment(checker, target);
+            }
             if checker.enabled(Rule::GlobalStatement) {
                 if let Expr::Name(ast::ExprName { id, .. }) = target.as_ref() {
                     pylint::rules::global_statement(checker, id);
@@ -1406,6 +1409,11 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             }
         }
         Stmt::Assign(assign @ ast::StmtAssign { targets, value, .. }) => {
+            if checker.enabled(Rule::SelfClsAssignment) {
+                for target in targets {
+                    pylint::rules::self_cls_assignment(checker, target);
+                }
+            }
             if checker.enabled(Rule::RedeclaredAssignedName) {
                 pylint::rules::redeclared_assigned_name(checker, targets);
             }
@@ -1540,6 +1548,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     );
                 }
             }
+            if checker.enabled(Rule::SelfClsAssignment) {
+                pylint::rules::self_cls_assignment(checker, target);
+            }
             if checker.enabled(Rule::SelfAssigningVariable) {
                 pylint::rules::self_annotated_assignment(checker, assign_stmt);
             }

crates/ruff_linter/src/codes.rs

@@ -310,6 +310,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "W0602") => (RuleGroup::Stable, rules::pylint::rules::GlobalVariableNotAssigned),
         (Pylint, "W0603") => (RuleGroup::Stable, rules::pylint::rules::GlobalStatement),
         (Pylint, "W0604") => (RuleGroup::Preview, rules::pylint::rules::GlobalAtModuleLevel),
+        (Pylint, "W0642") => (RuleGroup::Preview, rules::pylint::rules::SelfClsAssignment),
         (Pylint, "W0711") => (RuleGroup::Stable, rules::pylint::rules::BinaryOpException),
         (Pylint, "W1501") => (RuleGroup::Preview, rules::pylint::rules::BadOpenMode),
         (Pylint, "W1508") => (RuleGroup::Stable, rules::pylint::rules::InvalidEnvvarDefault),

crates/ruff_linter/src/rules/pylint/mod.rs

@@ -180,6 +180,7 @@ mod tests {
     #[test_case(Rule::NoStaticmethodDecorator, Path::new("no_method_decorator.py"))]
     #[test_case(Rule::PotentialIndexError, Path::new("potential_index_error.py"))]
     #[test_case(Rule::SuperWithoutBrackets, Path::new("super_without_brackets.py"))]
+    #[test_case(Rule::SelfClsAssignment, Path::new("self_cls_assignment.py"))]
     #[test_case(Rule::TooManyNestedBlocks, Path::new("too_many_nested_blocks.py"))]
     #[test_case(Rule::DictIterMissingItems, Path::new("dict_iter_missing_items.py"))]
     #[test_case(

crates/ruff_linter/src/rules/pylint/rules/mod.rs

@@ -60,6 +60,7 @@ pub(crate) use repeated_isinstance_calls::*;
 pub(crate) use repeated_keyword_argument::*;
 pub(crate) use return_in_init::*;
 pub(crate) use self_assigning_variable::*;
+pub(crate) use self_cls_assignment::*;
 pub(crate) use single_string_slots::*;
 pub(crate) use singledispatch_method::*;
 pub(crate) use singledispatchmethod_function::*;
@@ -156,6 +157,7 @@ mod repeated_isinstance_calls;
 mod repeated_keyword_argument;
 mod return_in_init;
 mod self_assigning_variable;
+mod self_cls_assignment;
 mod single_string_slots;
 mod singledispatch_method;
 mod singledispatchmethod_function;

crates/ruff_linter/src/rules/pylint/rules/self_cls_assignment.rs

@@ -0,0 +1,104 @@
+use ruff_python_ast::{self as ast, Expr};
+
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_semantic::{analyze::function_type, ScopeKind};
+use ruff_text_size::Ranged;
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for assignment of `self` and `cls` in methods.
+///
+/// ## Why is this bad?
+/// The identifiers `self` and `cls` are conventional in Python for
+/// the first argument of instance methods and class methods, respectively.
+///
+#[violation]
+pub struct SelfClsAssignment {
+    keyword: String,
+}
+
+impl Violation for SelfClsAssignment {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let SelfClsAssignment { keyword } = self;
+        format!("Assignment of variable `{keyword}`")
+    }
+}
+
+/// PLW0127
+pub(crate) fn self_cls_assignment(checker: &mut Checker, target: &Expr) {
+    let ScopeKind::Function(ast::StmtFunctionDef {
+        name,
+        decorator_list,
+        parameters,
+        ..
+    }) = checker.semantic().current_scope().kind
+    else {
+        return;
+    };
+
+    let Some(parent) = &checker
+        .semantic()
+        .first_non_type_parent_scope(checker.semantic().current_scope())
+    else {
+        return;
+    };
+
+    let keyword = match function_type::classify(
+        name,
+        decorator_list,
+        parent,
+        checker.semantic(),
+        &checker.settings.pep8_naming.classmethod_decorators,
+        &checker.settings.pep8_naming.staticmethod_decorators,
+    ) {
+        function_type::FunctionType::ClassMethod { .. } => {
+            let Some(first_arg) = parameters.args.first() else {
+                return;
+            };
+            if first_arg.parameter.name.as_str() != "cls" {
+                return;
+            }
+
+            "cls"
+        }
+        function_type::FunctionType::Method { .. } => {
+            let Some(first_arg) = parameters.args.first() else {
+                return;
+            };
+            if first_arg.parameter.name.as_str() != "self" {
+                return;
+            }
+
+            "self"
+        }
+        _ => return,
+    };
+
+    check_expr(checker, target, keyword);
+}
+
+fn check_expr(checker: &mut Checker, target: &Expr, keyword: &str) {
+    match target {
+        Expr::Name(_) => {
+            if let Expr::Name(ast::ExprName { id, .. }) = target {
+                if id.as_str() == keyword {
+                    checker.diagnostics.push(Diagnostic::new(
+                        SelfClsAssignment {
+                            keyword: keyword.to_string(),
+                        },
+                        target.range(),
+                    ));
+                }
+            }
+        }
+        Expr::Tuple(ast::ExprTuple { elts, .. }) => {
+            for element in elts {
+                check_expr(checker, element, keyword);
+            }
+        }
+        _ => {}
+    }
+}

crates/ruff_linter/src/rules/pylint/snapshots/ruff_linter__rules__pylint__tests__PLW0642_self_cls_assignment.py.snap

@@ -0,0 +1,101 @@
+---
+source: crates/ruff_linter/src/rules/pylint/mod.rs
+---
+self_cls_assignment.py:4:9: PLW0642 Assignment of variable `cls`
+  |
+2 |     @classmethod
+3 |     def list_fruits(cls) -> None:
+4 |         cls = "apple"  # PLW0642
+  |         ^^^ PLW0642
+5 |         cls: Fruit = "apple"  # PLW0642
+6 |         cls += "orange"  # PLW0642
+  |
+
+self_cls_assignment.py:5:9: PLW0642 Assignment of variable `cls`
+  |
+3 |     def list_fruits(cls) -> None:
+4 |         cls = "apple"  # PLW0642
+5 |         cls: Fruit = "apple"  # PLW0642
+  |         ^^^ PLW0642
+6 |         cls += "orange"  # PLW0642
+7 |         cls, blah = "apple", "orange"  # PLW0642
+  |
+
+self_cls_assignment.py:6:9: PLW0642 Assignment of variable `cls`
+  |
+4 |         cls = "apple"  # PLW0642
+5 |         cls: Fruit = "apple"  # PLW0642
+6 |         cls += "orange"  # PLW0642
+  |         ^^^ PLW0642
+7 |         cls, blah = "apple", "orange"  # PLW0642
+8 |         blah, (cls, blah2) = "apple", ("orange", "banana")  # PLW0642
+  |
+
+self_cls_assignment.py:7:9: PLW0642 Assignment of variable `cls`
+  |
+5 |         cls: Fruit = "apple"  # PLW0642
+6 |         cls += "orange"  # PLW0642
+7 |         cls, blah = "apple", "orange"  # PLW0642
+  |         ^^^ PLW0642
+8 |         blah, (cls, blah2) = "apple", ("orange", "banana")  # PLW0642
+  |
+
+self_cls_assignment.py:8:16: PLW0642 Assignment of variable `cls`
+   |
+ 6 |         cls += "orange"  # PLW0642
+ 7 |         cls, blah = "apple", "orange"  # PLW0642
+ 8 |         blah, (cls, blah2) = "apple", ("orange", "banana")  # PLW0642
+   |                ^^^ PLW0642
+ 9 | 
+10 |     def print_color(self) -> None:
+   |
+
+self_cls_assignment.py:11:9: PLW0642 Assignment of variable `self`
+   |
+10 |     def print_color(self) -> None:
+11 |         self = "red"  # PLW0642
+   |         ^^^^ PLW0642
+12 |         self: Self = "red"  # PLW0642
+13 |         self += "blue"  # PLW0642
+   |
+
+self_cls_assignment.py:12:9: PLW0642 Assignment of variable `self`
+   |
+10 |     def print_color(self) -> None:
+11 |         self = "red"  # PLW0642
+12 |         self: Self = "red"  # PLW0642
+   |         ^^^^ PLW0642
+13 |         self += "blue"  # PLW0642
+14 |         self, blah = "red", "blue"  # PLW0642
+   |
+
+self_cls_assignment.py:13:9: PLW0642 Assignment of variable `self`
+   |
+11 |         self = "red"  # PLW0642
+12 |         self: Self = "red"  # PLW0642
+13 |         self += "blue"  # PLW0642
+   |         ^^^^ PLW0642
+14 |         self, blah = "red", "blue"  # PLW0642
+15 |         blah, (self, blah2) = "apple", ("orange", "banana")  # PLW0642
+   |
+
+self_cls_assignment.py:14:9: PLW0642 Assignment of variable `self`
+   |
+12 |         self: Self = "red"  # PLW0642
+13 |         self += "blue"  # PLW0642
+14 |         self, blah = "red", "blue"  # PLW0642
+   |         ^^^^ PLW0642
+15 |         blah, (self, blah2) = "apple", ("orange", "banana")  # PLW0642
+   |
+
+self_cls_assignment.py:15:16: PLW0642 Assignment of variable `self`
+   |
+13 |         self += "blue"  # PLW0642
+14 |         self, blah = "red", "blue"  # PLW0642
+15 |         blah, (self, blah2) = "apple", ("orange", "banana")  # PLW0642
+   |                ^^^^ PLW0642
+16 |     
+17 |     def ok(self) -> None:
+   |
+
+