[pylint] Impement self-assigning-variable (W0127)

crates/ruff/resources/test/fixtures/pylint/self_assigning_variable.py

@@ -0,0 +1,36 @@
+foo = 1
+bar = 2
+baz = 3
+
+# Errors.
+foo = foo
+bar = bar
+foo, bar = foo, bar
+bar, foo = bar, foo
+(foo, bar) = (foo, bar)
+(bar, foo) = (bar, foo)
+foo, (bar, baz) = foo, (bar, baz)
+bar, (foo, baz) = bar, (foo, baz)
+(foo, bar), baz = (foo, bar), baz
+(foo, (bar, baz)) = (foo, (bar, baz))
+foo, bar = foo, 1
+bar, foo = bar, 1
+(foo, bar) = (foo, 1)
+(bar, foo) = (bar, 1)
+foo, (bar, baz) = foo, (bar, 1)
+bar, (foo, baz) = bar, (foo, 1)
+(foo, bar), baz = (foo, bar), 1
+(foo, (bar, baz)) = (foo, (bar, 1))
+foo: int = foo
+bar: int = bar
+
+# Non-errors.
+foo = bar
+bar = foo
+foo, bar = bar, foo
+foo, bar = bar, foo
+(foo, bar) = (bar, foo)
+foo, bar = bar, 1
+bar, foo = foo, 1
+foo: int = bar
+bar: int = 1

crates/ruff/src/checkers/ast/mod.rs

@@ -1583,6 +1583,9 @@ where
                         self.diagnostics.push(diagnostic);
                     }
                 }
+                if self.settings.rules.enabled(Rule::SelfAssigningVariable) {
+                    pylint::rules::self_assigning_variable(self, targets, value);
+                }
                 if self.settings.rules.enabled(Rule::TypeParamNameMismatch) {
                     pylint::rules::type_param_name_mismatch(self, value, targets);
                 }
@@ -1654,6 +1657,15 @@ where
                         stmt,
                     );
                 }
+                if self.settings.rules.enabled(Rule::SelfAssigningVariable) {
+                    if let Some(value) = value {
+                        pylint::rules::self_assigning_variable(
+                            self,
+                            &[target.as_ref().clone()],
+                            value,
+                        );
+                    }
+                }
                 if self.is_stub {
                     if let Some(value) = value {
                         if self.enabled(Rule::AssignmentDefaultInStub) {

crates/ruff/src/codes.rs

@@ -172,10 +172,10 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "C0131") => (RuleGroup::Unspecified, rules::pylint::rules::TypeBivariance),
         (Pylint, "C0132") => (RuleGroup::Unspecified, rules::pylint::rules::TypeParamNameMismatch),
         (Pylint, "C0205") => (RuleGroup::Unspecified, rules::pylint::rules::SingleStringSlots),
+        (Pylint, "C0208") => (RuleGroup::Unspecified, rules::pylint::rules::IterationOverSet),
         (Pylint, "C0414") => (RuleGroup::Unspecified, rules::pylint::rules::UselessImportAlias),
         (Pylint, "C1901") => (RuleGroup::Nursery, rules::pylint::rules::CompareToEmptyString),
         (Pylint, "C3002") => (RuleGroup::Unspecified, rules::pylint::rules::UnnecessaryDirectLambdaCall),
-        (Pylint, "C0208") => (RuleGroup::Unspecified, rules::pylint::rules::IterationOverSet),
         (Pylint, "E0100") => (RuleGroup::Unspecified, rules::pylint::rules::YieldInInit),
         (Pylint, "E0101") => (RuleGroup::Unspecified, rules::pylint::rules::ReturnInInit),
         (Pylint, "E0116") => (RuleGroup::Unspecified, rules::pylint::rules::ContinueInFinally),
@@ -214,6 +214,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "R2004") => (RuleGroup::Unspecified, rules::pylint::rules::MagicValueComparison),
         (Pylint, "R5501") => (RuleGroup::Unspecified, rules::pylint::rules::CollapsibleElseIf),
         (Pylint, "W0120") => (RuleGroup::Unspecified, rules::pylint::rules::UselessElseOnLoop),
+        (Pylint, "W0127") => (RuleGroup::Unspecified, rules::pylint::rules::SelfAssigningVariable),
         (Pylint, "W0129") => (RuleGroup::Unspecified, rules::pylint::rules::AssertOnStringLiteral),
         (Pylint, "W0131") => (RuleGroup::Unspecified, rules::pylint::rules::NamedExprWithoutContext),
         (Pylint, "W0406") => (RuleGroup::Unspecified, rules::pylint::rules::ImportSelf),

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

@@ -116,6 +116,7 @@ mod tests {
         Rule::RepeatedEqualityComparisonTarget,
         Path::new("repeated_equality_comparison_target.py")
     )]
+    #[test_case(Rule::SelfAssigningVariable, Path::new("self_assigning_variable.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
         let diagnostics = test_path(

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

@@ -32,6 +32,7 @@ pub(crate) use redefined_loop_name::*;
 pub(crate) use repeated_equality_comparison_target::*;
 pub(crate) use repeated_isinstance_calls::*;
 pub(crate) use return_in_init::*;
+pub(crate) use self_assigning_variable::*;
 pub(crate) use single_string_slots::*;
 pub(crate) use sys_exit_alias::*;
 pub(crate) use too_many_arguments::*;
@@ -83,6 +84,7 @@ mod redefined_loop_name;
 mod repeated_equality_comparison_target;
 mod repeated_isinstance_calls;
 mod return_in_init;
+mod self_assigning_variable;
 mod single_string_slots;
 mod sys_exit_alias;
 mod too_many_arguments;

crates/ruff/src/rules/pylint/rules/self_assigning_variable.rs

@@ -0,0 +1,65 @@
+use rustpython_parser::ast::{self, Expr, Ranged};
+
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_macros::{derive_message_formats, violation};
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for self-assignment of variables.
+///
+/// ## Why is this bad?
+/// Self-assignment of variables is redundant and likely a mistake.
+///
+/// ## Example
+/// ```python
+/// country = "Poland"
+/// country = country
+/// ```
+///
+/// Use instead:
+/// ```python
+/// country = "Poland"
+/// ```
+#[violation]
+pub struct SelfAssigningVariable {
+    name: String,
+}
+
+impl Violation for SelfAssigningVariable {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let SelfAssigningVariable { name } = self;
+        format!("Self-assignment of variable `{name}`")
+    }
+}
+
+/// PLW0127
+pub(crate) fn self_assigning_variable(checker: &mut Checker, targets: &[Expr], value: &Expr) {
+    let [target] = targets else {
+        return;
+    };
+    match (target, value) {
+        (
+            Expr::Tuple(ast::ExprTuple { elts: lhs_elts, .. }),
+            Expr::Tuple(ast::ExprTuple { elts: rhs_elts, .. }),
+        ) if lhs_elts.len() == rhs_elts.len() => {
+            lhs_elts
+                .iter()
+                .zip(rhs_elts.iter())
+                .for_each(|(lhs, rhs)| self_assigning_variable(checker, &[lhs.clone()], rhs));
+        }
+        (
+            Expr::Name(ast::ExprName { id: lhs_name, .. }),
+            Expr::Name(ast::ExprName { id: rhs_name, .. }),
+        ) if lhs_name == rhs_name => {
+            checker.diagnostics.push(Diagnostic::new(
+                SelfAssigningVariable {
+                    name: lhs_name.to_string(),
+                },
+                target.range(),
+            ));
+        }
+        _ => {}
+    }
+}