[ruff] Catch more dummy variable uses (RUF052) (#19799)

## Summary

Extends the `used-dummy-variable` rule
([RUF052](https://docs.astral.sh/ruff/rules/used-dummy-variable/)) to
detect dummy variables that are used within list comprehensions, dict
comprehensions, set comprehensions, and generator expressions, not just
regular for loops and function assignments.

### Problem

Previously, RUF052 only flagged dummy variables (variables with leading
underscores) that were used in function scopes via assignments or
regular for loops. It missed cases where dummy variables were used
within comprehensions:

```python
def example():
    my_list = [{"foo": 1}, {"foo": 2}]
    
    # These were not detected before:
    [_item["foo"] for _item in my_list]  # Should warn: _item is used
    {_item["key"]: _item["val"] for _item in my_list}  # Should warn: _item is used
    (_item["foo"] for _item in my_list)  # Should warn: _item is used
```

### Solution

- Extended scope checking to include all generator scopes () with any
(list/dict/set comprehensions and generator expressions)
`ScopeKind::Generator``GeneratorKind`
- Added support for bindings, which cover loop variables in both regular
for loops and comprehensions `BindingKind::LoopVar`
- Refactored the scope validation logic for better readability with a
descriptive variable `is_allowed_scope`



[ISSUE](#19732)

## Test Plan

```bash
cargo test
```

---------

Co-authored-by: Brent Westbrook <brentrwestbrook@gmail.com>

Author: mikeleppane

…r/resources/test/fixtures/ruff/RUF052.py …resources/test/fixtures/ruff/RUF052_0.pycrates/ruff_linter/resources/test/fixtures/ruff/RUF052.py renamed to crates/ruff_linter/resources/test/fixtures/ruff/RUF052_0.py crates/ruff_linter/resources/test/fixtures/ruff/RUF052.py renamed to crates/ruff_linter/resources/test/fixtures/ruff/RUF052_0.py

@@ -0,0 +1,109 @@
+# Correct usage in loop and comprehension
+def process_data():
+    return 42
+def test_correct_dummy_usage():
+    my_list = [{"foo": 1}, {"foo": 2}]
+
+    # Should NOT detect - dummy variable is not used
+    [process_data() for _ in my_list]  # OK: `_` is ignored by rule
+
+    # Should NOT detect - dummy variable is not used
+    [item["foo"] for item in my_list]  # OK: not a dummy variable name
+
+    # Should NOT detect - dummy variable is not used
+    [42 for _unused in my_list]  # OK: `_unused` is not accessed
+
+# Regular For Loops
+def test_for_loops():
+    my_list = [{"foo": 1}, {"foo": 2}]
+
+    # Should detect used dummy variable
+    for _item in my_list:
+        print(_item["foo"])  # RUF052: Local dummy variable `_item` is accessed
+
+    # Should detect used dummy variable
+    for _index, _value in enumerate(my_list):
+        result = _index + _value["foo"]  # RUF052: Both `_index` and `_value` are accessed
+
+# List Comprehensions
+def test_list_comprehensions():
+    my_list = [{"foo": 1}, {"foo": 2}]
+
+    # Should detect used dummy variable
+    result = [_item["foo"] for _item in my_list]  # RUF052: Local dummy variable `_item` is accessed
+
+    # Should detect used dummy variable in nested comprehension
+    nested = [[_item["foo"] for _item in _sublist] for _sublist in [my_list, my_list]]
+    # RUF052: Both `_item` and `_sublist` are accessed
+
+    # Should detect with conditions
+    filtered = [_item["foo"] for _item in my_list if _item["foo"] > 0]
+    # RUF052: Local dummy variable `_item` is accessed
+
+# Dict Comprehensions
+def test_dict_comprehensions():
+    my_list = [{"key": "a", "value": 1}, {"key": "b", "value": 2}]
+
+    # Should detect used dummy variable
+    result = {_item["key"]: _item["value"] for _item in my_list}
+    # RUF052: Local dummy variable `_item` is accessed
+
+    # Should detect with enumerate
+    indexed = {_index: _item["value"] for _index, _item in enumerate(my_list)}
+    # RUF052: Both `_index` and `_item` are accessed
+
+    # Should detect in nested dict comprehension
+    nested = {_outer: {_inner["key"]: _inner["value"] for _inner in sublist}
+              for _outer, sublist in enumerate([my_list])}
+    # RUF052: `_outer`, `_inner` are accessed
+
+# Set Comprehensions
+def test_set_comprehensions():
+    my_list = [{"foo": 1}, {"foo": 2}, {"foo": 1}]  # Note: duplicate values
+
+    # Should detect used dummy variable
+    unique_values = {_item["foo"] for _item in my_list}
+    # RUF052: Local dummy variable `_item` is accessed
+
+    # Should detect with conditions
+    filtered_set = {_item["foo"] for _item in my_list if _item["foo"] > 0}
+    # RUF052: Local dummy variable `_item` is accessed
+
+    # Should detect with complex expression
+    processed = {_item["foo"] * 2 for _item in my_list}
+    # RUF052: Local dummy variable `_item` is accessed
+
+# Generator Expressions
+def test_generator_expressions():
+    my_list = [{"foo": 1}, {"foo": 2}]
+
+    # Should detect used dummy variable
+    gen = (_item["foo"] for _item in my_list)
+    # RUF052: Local dummy variable `_item` is accessed
+
+    # Should detect when passed to function
+    total = sum(_item["foo"] for _item in my_list)
+    # RUF052: Local dummy variable `_item` is accessed
+
+    # Should detect with multiple generators
+    pairs = ((_x, _y) for _x in range(3) for _y in range(3) if _x != _y)
+    # RUF052: Both `_x` and `_y` are accessed
+
+    # Should detect in nested generator
+    nested_gen = (sum(_inner["foo"] for _inner in sublist) for _sublist in [my_list] for sublist in _sublist)
+    # RUF052: `_inner` and `_sublist` are accessed
+
+# Complex Examples with Multiple Comprehension Types
+def test_mixed_comprehensions():
+    data = [{"items": [1, 2, 3]}, {"items": [4, 5, 6]}]
+
+    # Should detect in mixed comprehensions
+    result = [
+        {_key: [_val * 2 for _val in _record["items"]] for _key in ["doubled"]}
+        for _record in data
+    ]
+    # RUF052: `_key`, `_val`, and `_record` are all accessed
+
+    # Should detect in generator passed to list constructor
+    gen_list = list(_item["items"][0] for _item in data)
+    # RUF052: Local dummy variable `_item` is accessed

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

@@ -97,7 +97,8 @@ mod tests {
     #[test_case(Rule::MapIntVersionParsing, Path::new("RUF048_1.py"))]
     #[test_case(Rule::DataclassEnum, Path::new("RUF049.py"))]
     #[test_case(Rule::IfKeyInDictDel, Path::new("RUF051.py"))]
-    #[test_case(Rule::UsedDummyVariable, Path::new("RUF052.py"))]
+    #[test_case(Rule::UsedDummyVariable, Path::new("RUF052_0.py"))]
+    #[test_case(Rule::UsedDummyVariable, Path::new("RUF052_1.py"))]
     #[test_case(Rule::ClassWithMixedTypeVars, Path::new("RUF053.py"))]
     #[test_case(Rule::FalsyDictGetFallback, Path::new("RUF056.py"))]
     #[test_case(Rule::UnnecessaryRound, Path::new("RUF057.py"))]
@@ -621,8 +622,8 @@ mod tests {
         Ok(())
     }
 
-    #[test_case(Rule::UsedDummyVariable, Path::new("RUF052.py"), r"^_+", 1)]
-    #[test_case(Rule::UsedDummyVariable, Path::new("RUF052.py"), r"", 2)]
+    #[test_case(Rule::UsedDummyVariable, Path::new("RUF052_0.py"), r"^_+", 1)]
+    #[test_case(Rule::UsedDummyVariable, Path::new("RUF052_0.py"), r"", 2)]
     fn custom_regexp_preset(
         rule_code: Rule,
         path: &Path,

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

@@ -1,6 +1,6 @@
 use ruff_macros::{ViolationMetadata, derive_message_formats};
 use ruff_python_ast::helpers::is_dunder;
-use ruff_python_semantic::{Binding, BindingId};
+use ruff_python_semantic::{Binding, BindingId, BindingKind, ScopeKind};
 use ruff_python_stdlib::identifiers::is_identifier;
 use ruff_text_size::Ranged;
 
@@ -111,7 +111,7 @@ pub(crate) fn used_dummy_variable(checker: &Checker, binding: &Binding, binding_
         return;
     }
 
-    // We only emit the lint on variables defined via assignments.
+    // We only emit the lint on local variables.
     //
     // ## Why not also emit the lint on function parameters?
     //
@@ -127,8 +127,30 @@ pub(crate) fn used_dummy_variable(checker: &Checker, binding: &Binding, binding_
     // autofixing the diagnostic for assignments. See:
     // - <https://github.com/astral-sh/ruff/issues/14790>
     // - <https://github.com/astral-sh/ruff/issues/14799>
-    if !binding.kind.is_assignment() {
-        return;
+    match binding.kind {
+        BindingKind::Annotation
+        | BindingKind::Argument
+        | BindingKind::NamedExprAssignment
+        | BindingKind::Assignment
+        | BindingKind::LoopVar
+        | BindingKind::WithItemVar
+        | BindingKind::BoundException
+        | BindingKind::UnboundException(_) => {}
+
+        BindingKind::TypeParam
+        | BindingKind::Global(_)
+        | BindingKind::Nonlocal(_, _)
+        | BindingKind::Builtin
+        | BindingKind::ClassDefinition(_)
+        | BindingKind::FunctionDefinition(_)
+        | BindingKind::Export(_)
+        | BindingKind::FutureImport
+        | BindingKind::Import(_)
+        | BindingKind::FromImport(_)
+        | BindingKind::SubmoduleImport(_)
+        | BindingKind::Deletion
+        | BindingKind::ConditionalDeletion(_)
+        | BindingKind::DunderClassCell => return,
     }
 
     // This excludes `global` and `nonlocal` variables.
@@ -138,9 +160,12 @@ pub(crate) fn used_dummy_variable(checker: &Checker, binding: &Binding, binding_
 
     let semantic = checker.semantic();
 
-    // Only variables defined in function scopes
+    // Only variables defined in function and generator scopes
     let scope = &semantic.scopes[binding.scope];
-    if !scope.kind.is_function() {
+    if !matches!(
+        scope.kind,
+        ScopeKind::Function(_) | ScopeKind::Generator { .. }
+    ) {
         return;
     }
 

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

@@ -2,7 +2,7 @@
 source: crates/ruff_linter/src/rules/ruff/mod.rs
 ---
 RUF052 [*] Local dummy variable `_var` is accessed
-  --> RUF052.py:92:9
+  --> RUF052_0.py:92:9
    |
 90 | class Class_:
 91 |     def fun(self):
@@ -24,7 +24,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_list` is accessed
-   --> RUF052.py:99:5
+   --> RUF052_0.py:99:5
     |
  98 | def fun():
  99 |     _list = "built-in" # [RUF052]
@@ -45,7 +45,7 @@ help: Prefer using trailing underscores to avoid shadowing a built-in
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_x` is accessed
-   --> RUF052.py:106:5
+   --> RUF052_0.py:106:5
     |
 104 | def fun():
 105 |     global x
@@ -67,7 +67,7 @@ help: Prefer using trailing underscores to avoid shadowing a variable
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_x` is accessed
-   --> RUF052.py:113:5
+   --> RUF052_0.py:113:5
     |
 111 |   def bar():
 112 |     nonlocal x
@@ -90,7 +90,7 @@ help: Prefer using trailing underscores to avoid shadowing a variable
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_x` is accessed
-   --> RUF052.py:120:5
+   --> RUF052_0.py:120:5
     |
 118 | def fun():
 119 |     x = "local"
@@ -112,7 +112,7 @@ help: Prefer using trailing underscores to avoid shadowing a variable
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 Local dummy variable `_GLOBAL_1` is accessed
-   --> RUF052.py:128:5
+   --> RUF052_0.py:128:5
     |
 127 | def unfixables():
 128 |     _GLOBAL_1 = "foo"
@@ -123,7 +123,7 @@ RUF052 Local dummy variable `_GLOBAL_1` is accessed
 help: Prefer using trailing underscores to avoid shadowing a variable
 
 RUF052 Local dummy variable `_local` is accessed
-   --> RUF052.py:136:5
+   --> RUF052_0.py:136:5
     |
 135 |     # unfixable because the rename would shadow a local variable
 136 |     _local = "local3"  # [RUF052]
@@ -133,7 +133,7 @@ RUF052 Local dummy variable `_local` is accessed
 help: Prefer using trailing underscores to avoid shadowing a variable
 
 RUF052 Local dummy variable `_GLOBAL_1` is accessed
-   --> RUF052.py:140:9
+   --> RUF052_0.py:140:9
     |
 139 |     def nested():
 140 |         _GLOBAL_1 = "foo"
@@ -144,7 +144,7 @@ RUF052 Local dummy variable `_GLOBAL_1` is accessed
 help: Prefer using trailing underscores to avoid shadowing a variable
 
 RUF052 Local dummy variable `_local` is accessed
-   --> RUF052.py:145:9
+   --> RUF052_0.py:145:9
     |
 144 |         # unfixable because the rename would shadow a variable from the outer function
 145 |         _local = "local4"
@@ -154,7 +154,7 @@ RUF052 Local dummy variable `_local` is accessed
 help: Prefer using trailing underscores to avoid shadowing a variable
 
 RUF052 [*] Local dummy variable `_P` is accessed
-   --> RUF052.py:153:5
+   --> RUF052_0.py:153:5
     |
 151 |     from collections import namedtuple
 152 |
@@ -184,7 +184,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_T` is accessed
-   --> RUF052.py:154:5
+   --> RUF052_0.py:154:5
     |
 153 |     _P = ParamSpec("_P")
 154 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
@@ -213,7 +213,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_NT` is accessed
-   --> RUF052.py:155:5
+   --> RUF052_0.py:155:5
     |
 153 |     _P = ParamSpec("_P")
 154 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
@@ -242,7 +242,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_E` is accessed
-   --> RUF052.py:156:5
+   --> RUF052_0.py:156:5
     |
 154 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
 155 |     _NT = NamedTuple("_NT", [("foo", int)])
@@ -270,7 +270,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_NT2` is accessed
-   --> RUF052.py:157:5
+   --> RUF052_0.py:157:5
     |
 155 |     _NT = NamedTuple("_NT", [("foo", int)])
 156 |     _E = Enum("_E", ["a", "b", "c"])
@@ -297,7 +297,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_NT3` is accessed
-   --> RUF052.py:158:5
+   --> RUF052_0.py:158:5
     |
 156 |     _E = Enum("_E", ["a", "b", "c"])
 157 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
@@ -323,7 +323,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_DynamicClass` is accessed
-   --> RUF052.py:159:5
+   --> RUF052_0.py:159:5
     |
 157 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
 158 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
@@ -347,7 +347,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_NotADynamicClass` is accessed
-   --> RUF052.py:160:5
+   --> RUF052_0.py:160:5
     |
 158 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
 159 |     _DynamicClass = type("_DynamicClass", (), {})
@@ -371,7 +371,7 @@ help: Remove leading underscores
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 [*] Local dummy variable `_dummy_var` is accessed
-   --> RUF052.py:182:5
+   --> RUF052_0.py:182:5
     |
 181 | def foo():
 182 |     _dummy_var = 42
@@ -396,7 +396,7 @@ help: Prefer using trailing underscores to avoid shadowing a variable
 note: This is an unsafe fix and may change runtime behavior
 
 RUF052 Local dummy variable `_dummy_var` is accessed
-   --> RUF052.py:192:5
+   --> RUF052_0.py:192:5
     |
 190 |     # Unfixable because both possible candidates for the new name are shadowed
 191 |     # in the scope of one of the references to the variable