[ruff] Implemented used-dummy-variable (RUF052)

crates/ruff_linter/resources/test/fixtures/ruff/RUF052.py

@@ -0,0 +1,93 @@
+# Correct
+
+for _ in range(5):
+    pass
+
+_valid_type = int
+
+_valid_var_1: _valid_type
+
+_valid_var_1 = 1
+
+_valid_var_2 = 2
+
+_valid_var_3 = _valid_var_1 + _valid_var_2
+
+def _valid_fun():
+    pass    
+
+_valid_fun()
+
+def fun(arg):
+    _valid_unused_var = arg
+    pass
+
+class _ValidClass:
+    pass
+
+_ValidClass()
+
+class ClassOk:
+    _valid_private_cls_attr = 1
+
+    print(_valid_private_cls_attr)
+
+    def __init__(self):
+        self._valid_private_ins_attr = 2
+        print(self._valid_private_ins_attr)
+
+    def _valid_method(self):
+        return self._valid_private_ins_attr
+
+    def method(arg):
+        _valid_unused_var = arg
+        return 
+
+# Correct if dummy_variable_re = "_+"
+
+def fun(x):
+    _ = 1
+    __ = 2
+    ___ = 3
+    if x == 1:
+        return _
+    if x == 2:
+        return __
+    if x == 3:
+        return ___
+    return x
+
+# Incorrect
+
+class Class_:
+    def fun(self):
+        _var = "method variable"
+        return _var # [RUF052]
+
+def fun(_var):
+    return _var # [RUF052]
+
+def fun():
+    _list = "built-in"
+    return _list # [RUF052]
+
+x = "global"
+
+def fun():
+    global x
+    _x = "shadows global"
+    return _x # [RUF052]
+
+def foo():
+  x = "outer"
+  def bar():
+    nonlocal x
+    _x = "shadows nonlocal"
+    return _x # [RUF052]
+  bar()
+  return x
+
+def fun():
+    x = "local"
+    _x = "shadows local"
+    return _x # [RUF052]

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

@@ -18,6 +18,7 @@ pub(crate) fn bindings(checker: &mut Checker) {
         Rule::UnsortedDunderSlots,
         Rule::UnusedVariable,
         Rule::UnquotedTypeAlias,
+        Rule::UnusedVariableAccessed,
     ]) {
         return;
     }
@@ -87,5 +88,10 @@ pub(crate) fn bindings(checker: &mut Checker) {
                 checker.diagnostics.push(diagnostic);
             }
         }
+        if checker.enabled(Rule::UnusedVariableAccessed) {
+            if let Some(diagnostics) = ruff::rules::unused_variable_accessed(checker, binding) {
+                checker.diagnostics.extend(diagnostics);
+            }
+        }
     }
 }

crates/ruff_linter/src/codes.rs

@@ -984,6 +984,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "040") => (RuleGroup::Preview, rules::ruff::rules::InvalidAssertMessageLiteralArgument),
         (Ruff, "041") => (RuleGroup::Preview, rules::ruff::rules::UnnecessaryNestedLiteral),
         (Ruff, "048") => (RuleGroup::Preview, rules::ruff::rules::MapIntVersionParsing),
+        (Ruff, "052") => (RuleGroup::Preview, rules::ruff::rules::UnusedVariableAccessed),
         (Ruff, "100") => (RuleGroup::Stable, rules::ruff::rules::UnusedNOQA),
         (Ruff, "101") => (RuleGroup::Stable, rules::ruff::rules::RedirectedNOQA),
 

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

@@ -10,6 +10,7 @@ mod tests {
     use std::path::Path;
 
     use anyhow::Result;
+    use regex::Regex;
     use rustc_hash::FxHashSet;
     use test_case::test_case;
 
@@ -448,4 +449,16 @@ mod tests {
         assert_messages!(snapshot, diagnostics);
         Ok(())
     }
+    #[test]
+    fn dummy_variable_unset() -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("ruff/RUF052.py"),
+            &LinterSettings {
+                dummy_variable_rgx: Regex::new(r"^_+$").unwrap(),
+                ..LinterSettings::for_rule(Rule::UnusedVariableAccessed)
+            },
+        )?;
+        assert_messages!(diagnostics);
+        Ok(())
+    }
 }

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

@@ -92,3 +92,6 @@ pub(crate) enum Context {
     Docstring,
     Comment,
 }
+pub(crate) use unused_variable_accessed::*;
+
+mod unused_variable_accessed;

crates/ruff_linter/src/rules/ruff/rules/unused_variable_accessed.rs

@@ -0,0 +1,124 @@
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_macros::{derive_message_formats, ViolationMetadata};
+use ruff_python_semantic::Binding;
+use ruff_python_stdlib::builtins::is_python_builtin;
+use ruff_text_size::Ranged;
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for usages of variables marked as unused (variable names starting with an underscore, except '_') in functions.
+/// Forbid using method and function variables that are marked as unused.
+///
+/// ## Why is this bad?
+/// Marking variables with a leading underscore conveys that they are intentionally unused within the function or method.
+/// When these variables are later referenced in the code, it causes confusion and potential misunderstandings about
+/// the code's intention. A variable marked as "unused" but subsequently used suggests oversight or unintentional use
+/// and detracts from the clarity and maintainability of the codebase.
+///
+/// ## Example
+/// ```python
+/// def function():
+///     _variable = 3
+///     return _variable + 1
+/// ```
+///
+/// Use instead:
+/// ```python
+/// def function():
+///     variable = 3
+///     return variable + 1
+/// ```
+#[derive(ViolationMetadata)]
+pub(crate) struct UnusedVariableAccessed {
+    name: String,
+    // fix: String,
+    shadowed_kind: ShadowedKind,
+}
+
+impl Violation for UnusedVariableAccessed {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!(
+            "Local variable `{}` marked as unused is accessed",
+            self.name
+        )
+    }
+
+    fn fix_title(&self) -> Option<String> {
+        Some(match self.shadowed_kind {
+            ShadowedKind::BuiltIn => {
+                "Consider using preferred trailing underscores to avoid shadowing a built-in."
+                    .to_string()
+            }
+            ShadowedKind::Some => {
+                "Consider using preferred trailing underscores to avoid shadowing a variable."
+                    .to_string()
+            }
+            ShadowedKind::None => "Consider removing leading underscores.".to_string(),
+        })
+    }
+}
+
+/// RUF052
+pub(crate) fn unused_variable_accessed(
+    checker: &Checker,
+    binding: &Binding,
+) -> Option<Vec<Diagnostic>> {
+    let name = binding.name(checker.source());
+
+    // only used variables
+    if !name.starts_with('_')
+        || name == "_"
+        || binding.is_unused()
+        || binding.is_global()
+        || binding.is_nonlocal()
+        || (!binding.kind.is_argument() && !binding.kind.is_assignment())
+        || !checker.semantic().scopes[binding.scope].kind.is_function()
+        || checker.settings.dummy_variable_rgx.is_match(name)
+    {
+        return None;
+    }
+
+    let trimmed_name = name.trim_start_matches('_');
+    let mut kind = ShadowedKind::None;
+    // let mut fix = trimmed_name.to_string();
+
+    if !trimmed_name.is_empty() {
+        if is_python_builtin(
+            trimmed_name,
+            checker.settings.target_version.minor(),
+            checker.source_type.is_ipynb(),
+        ) {
+            kind = ShadowedKind::BuiltIn;
+            // fix += "_";
+        } else if checker.semantic().scopes[binding.scope].has(trimmed_name) {
+            kind = ShadowedKind::Some;
+            // fix += "_";
+        }
+    }
+
+    Some(
+        binding
+            .references
+            .iter()
+            .map(|ref_id| {
+                Diagnostic::new(
+                    UnusedVariableAccessed {
+                        name: name.to_string(),
+                        // fix: fix.clone(),
+                        shadowed_kind: kind,
+                    },
+                    checker.semantic().reference(*ref_id).range(),
+                )
+            })
+            .collect(),
+    )
+}
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+enum ShadowedKind {
+    Some,
+    BuiltIn,
+    None,
+}

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__dummy_variable_unset.snap

@@ -0,0 +1,66 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+snapshot_kind: text
+---
+RUF052.py:65:16: RUF052 Local variable `_var` marked as unused is accessed
+   |
+63 |     def fun(self):
+64 |         _var = "method variable"
+65 |         return _var # [RUF052]
+   |                ^^^^ RUF052
+66 | 
+67 | def fun(_var):
+   |
+   = help: Consider removing leading underscores.
+
+RUF052.py:68:12: RUF052 Local variable `_var` marked as unused is accessed
+   |
+67 | def fun(_var):
+68 |     return _var # [RUF052]
+   |            ^^^^ RUF052
+69 | 
+70 | def fun():
+   |
+   = help: Consider removing leading underscores.
+
+RUF052.py:72:12: RUF052 Local variable `_list` marked as unused is accessed
+   |
+70 | def fun():
+71 |     _list = "built-in"
+72 |     return _list # [RUF052]
+   |            ^^^^^ RUF052
+73 | 
+74 | x = "global"
+   |
+   = help: Consider using preferred trailing underscores to avoid shadowing a built-in.
+
+RUF052.py:79:12: RUF052 Local variable `_x` marked as unused is accessed
+   |
+77 |     global x
+78 |     _x = "shadows global"
+79 |     return _x # [RUF052]
+   |            ^^ RUF052
+80 | 
+81 | def foo():
+   |
+   = help: Consider using preferred trailing underscores to avoid shadowing a variable.
+
+RUF052.py:86:12: RUF052 Local variable `_x` marked as unused is accessed
+   |
+84 |     nonlocal x
+85 |     _x = "shadows nonlocal"
+86 |     return _x # [RUF052]
+   |            ^^ RUF052
+87 |   bar()
+88 |   return x
+   |
+   = help: Consider using preferred trailing underscores to avoid shadowing a variable.
+
+RUF052.py:93:12: RUF052 Local variable `_x` marked as unused is accessed
+   |
+91 |     x = "local"
+92 |     _x = "shadows local"
+93 |     return _x # [RUF052]
+   |            ^^ RUF052
+   |
+   = help: Consider using preferred trailing underscores to avoid shadowing a variable.