---
source: crates/ruff_linter/src/rules/ruff/mod.rs
---
RUF052.py:77:9: RUF052 [*] Local dummy variable `_var` is accessed
   |
75 | class Class_:
76 |     def fun(self):
77 |         _var = "method variable" # [RUF052]
   |         ^^^^ RUF052
78 |         return _var
   |
   = help: Remove leading underscores

ℹ Unsafe fix
74 74 | 
75 75 | class Class_:
76 76 |     def fun(self):
77    |-        _var = "method variable" # [RUF052]
78    |-        return _var
   77 |+        var = "method variable" # [RUF052]
   78 |+        return var
79 79 | 
80 80 | def fun(_var): # parameters are ignored
81 81 |     return _var

RUF052.py:84:5: RUF052 [*] Local dummy variable `_list` is accessed
   |
83 | def fun():
84 |     _list = "built-in" # [RUF052]
   |     ^^^^^ RUF052
85 |     return _list
   |
   = help: Prefer using trailing underscores to avoid shadowing a built-in

ℹ Unsafe fix
81 81 |     return _var
82 82 | 
83 83 | def fun():
84    |-    _list = "built-in" # [RUF052]
85    |-    return _list
   84 |+    list_ = "built-in" # [RUF052]
   85 |+    return list_
86 86 | 
87 87 | x = "global"
88 88 | 

RUF052.py:91:5: RUF052 [*] Local dummy variable `_x` is accessed
   |
89 | def fun():
90 |     global x
91 |     _x = "shadows global" # [RUF052]
   |     ^^ RUF052
92 |     return _x
   |
   = help: Prefer using trailing underscores to avoid shadowing a variable

ℹ Unsafe fix
88 88 | 
89 89 | def fun():
90 90 |     global x
91    |-    _x = "shadows global" # [RUF052]
92    |-    return _x
   91 |+    x_ = "shadows global" # [RUF052]
   92 |+    return x_
93 93 | 
94 94 | def foo():
95 95 |   x = "outer"

RUF052.py:98:5: RUF052 [*] Local dummy variable `_x` is accessed
    |
 96 |   def bar():
 97 |     nonlocal x
 98 |     _x = "shadows nonlocal" # [RUF052]
    |     ^^ RUF052
 99 |     return _x
100 |   bar()
    |
    = help: Prefer using trailing underscores to avoid shadowing a variable

ℹ Unsafe fix
95  95  |   x = "outer"
96  96  |   def bar():
97  97  |     nonlocal x
98      |-    _x = "shadows nonlocal" # [RUF052]
99      |-    return _x
    98  |+    x_ = "shadows nonlocal" # [RUF052]
    99  |+    return x_
100 100 |   bar()
101 101 |   return x
102 102 | 

RUF052.py:105:5: RUF052 [*] Local dummy variable `_x` is accessed
    |
103 | def fun():
104 |     x = "local"
105 |     _x = "shadows local" # [RUF052]
    |     ^^ RUF052
106 |     return _x
    |
    = help: Prefer using trailing underscores to avoid shadowing a variable

ℹ Unsafe fix
102 102 | 
103 103 | def fun():
104 104 |     x = "local"
105     |-    _x = "shadows local" # [RUF052]
106     |-    return _x
    105 |+    x_ = "shadows local" # [RUF052]
    106 |+    return x_
107 107 | 
108 108 | 
109 109 | GLOBAL_1 = "global 1"

RUF052.py:113:5: RUF052 Local dummy variable `_GLOBAL_1` is accessed
    |
112 | def unfixables():
113 |     _GLOBAL_1 = "foo"
    |     ^^^^^^^^^ RUF052
114 |     # unfixable because the rename would shadow a global variable
115 |     print(_GLOBAL_1)  # [RUF052]
    |
    = help: Prefer using trailing underscores to avoid shadowing a variable

RUF052.py:121:5: RUF052 Local dummy variable `_local` is accessed
    |
120 |     # unfixable because the rename would shadow a local variable
121 |     _local = "local3"  # [RUF052]
    |     ^^^^^^ RUF052
122 |     print(_local)
    |
    = help: Prefer using trailing underscores to avoid shadowing a variable

RUF052.py:125:9: RUF052 Local dummy variable `_GLOBAL_1` is accessed
    |
124 |     def nested():
125 |         _GLOBAL_1 = "foo"
    |         ^^^^^^^^^ RUF052
126 |         # unfixable because the rename would shadow a global variable
127 |         print(_GLOBAL_1)  # [RUF052]
    |
    = help: Prefer using trailing underscores to avoid shadowing a variable

RUF052.py:130:9: RUF052 Local dummy variable `_local` is accessed
    |
129 |         # unfixable because the rename would shadow a variable from the outer function
130 |         _local = "local4"
    |         ^^^^^^ RUF052
131 |         print(_local)
    |
    = help: Prefer using trailing underscores to avoid shadowing a variable

RUF052.py:138:5: RUF052 [*] Local dummy variable `_P` is accessed
    |
136 |     from collections import namedtuple
137 | 
138 |     _P = ParamSpec("_P")
    |     ^^ RUF052
139 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
140 |     _NT = NamedTuple("_NT", [("foo", int)])
    |
    = help: Remove leading underscores

ℹ Unsafe fix
135 135 |     from enum import Enum
136 136 |     from collections import namedtuple
137 137 | 
138     |-    _P = ParamSpec("_P")
    138 |+    P = ParamSpec("P")
139 139 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
140 140 |     _NT = NamedTuple("_NT", [("foo", int)])
141 141 |     _E = Enum("_E", ["a", "b", "c"])
--------------------------------------------------------------------------------
144 144 |     _DynamicClass = type("_DynamicClass", (), {})
145 145 |     _NotADynamicClass = type("_NotADynamicClass")
146 146 | 
147     |-    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    147 |+    print(_T, P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)

RUF052.py:139:5: RUF052 [*] Local dummy variable `_T` is accessed
    |
138 |     _P = ParamSpec("_P")
139 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
    |     ^^ RUF052
140 |     _NT = NamedTuple("_NT", [("foo", int)])
141 |     _E = Enum("_E", ["a", "b", "c"])
    |
    = help: Remove leading underscores

ℹ Unsafe fix
136 136 |     from collections import namedtuple
137 137 | 
138 138 |     _P = ParamSpec("_P")
139     |-    _T = TypeVar(name="_T", covariant=True, bound=int|str)
    139 |+    T = TypeVar(name="T", covariant=True, bound=int|str)
140 140 |     _NT = NamedTuple("_NT", [("foo", int)])
141 141 |     _E = Enum("_E", ["a", "b", "c"])
142 142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
--------------------------------------------------------------------------------
144 144 |     _DynamicClass = type("_DynamicClass", (), {})
145 145 |     _NotADynamicClass = type("_NotADynamicClass")
146 146 | 
147     |-    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    147 |+    print(T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)

RUF052.py:140:5: RUF052 [*] Local dummy variable `_NT` is accessed
    |
138 |     _P = ParamSpec("_P")
139 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
140 |     _NT = NamedTuple("_NT", [("foo", int)])
    |     ^^^ RUF052
141 |     _E = Enum("_E", ["a", "b", "c"])
142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
    |
    = help: Remove leading underscores

ℹ Unsafe fix
137 137 | 
138 138 |     _P = ParamSpec("_P")
139 139 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
140     |-    _NT = NamedTuple("_NT", [("foo", int)])
    140 |+    NT = NamedTuple("NT", [("foo", int)])
141 141 |     _E = Enum("_E", ["a", "b", "c"])
142 142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
143 143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
144 144 |     _DynamicClass = type("_DynamicClass", (), {})
145 145 |     _NotADynamicClass = type("_NotADynamicClass")
146 146 | 
147     |-    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    147 |+    print(_T, _P, NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)

RUF052.py:141:5: RUF052 [*] Local dummy variable `_E` is accessed
    |
139 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
140 |     _NT = NamedTuple("_NT", [("foo", int)])
141 |     _E = Enum("_E", ["a", "b", "c"])
    |     ^^ RUF052
142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
    |
    = help: Remove leading underscores

ℹ Unsafe fix
138 138 |     _P = ParamSpec("_P")
139 139 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
140 140 |     _NT = NamedTuple("_NT", [("foo", int)])
141     |-    _E = Enum("_E", ["a", "b", "c"])
    141 |+    E = Enum("E", ["a", "b", "c"])
142 142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
143 143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
144 144 |     _DynamicClass = type("_DynamicClass", (), {})
145 145 |     _NotADynamicClass = type("_NotADynamicClass")
146 146 | 
147     |-    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    147 |+    print(_T, _P, _NT, E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)

RUF052.py:142:5: RUF052 [*] Local dummy variable `_NT2` is accessed
    |
140 |     _NT = NamedTuple("_NT", [("foo", int)])
141 |     _E = Enum("_E", ["a", "b", "c"])
142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
    |     ^^^^ RUF052
143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
144 |     _DynamicClass = type("_DynamicClass", (), {})
    |
    = help: Remove leading underscores

ℹ Unsafe fix
139 139 |     _T = TypeVar(name="_T", covariant=True, bound=int|str)
140 140 |     _NT = NamedTuple("_NT", [("foo", int)])
141 141 |     _E = Enum("_E", ["a", "b", "c"])
142     |-    _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
    142 |+    NT2 = namedtuple("NT2", ['x', 'y', 'z'])
143 143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
144 144 |     _DynamicClass = type("_DynamicClass", (), {})
145 145 |     _NotADynamicClass = type("_NotADynamicClass")
146 146 | 
147     |-    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    147 |+    print(_T, _P, _NT, _E, NT2, _NT3, _DynamicClass, _NotADynamicClass)

RUF052.py:143:5: RUF052 [*] Local dummy variable `_NT3` is accessed
    |
141 |     _E = Enum("_E", ["a", "b", "c"])
142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
    |     ^^^^ RUF052
144 |     _DynamicClass = type("_DynamicClass", (), {})
145 |     _NotADynamicClass = type("_NotADynamicClass")
    |
    = help: Remove leading underscores

ℹ Unsafe fix
140 140 |     _NT = NamedTuple("_NT", [("foo", int)])
141 141 |     _E = Enum("_E", ["a", "b", "c"])
142 142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
143     |-    _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
    143 |+    NT3 = namedtuple(typename="NT3", field_names=['x', 'y', 'z'])
144 144 |     _DynamicClass = type("_DynamicClass", (), {})
145 145 |     _NotADynamicClass = type("_NotADynamicClass")
146 146 | 
147     |-    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    147 |+    print(_T, _P, _NT, _E, _NT2, NT3, _DynamicClass, _NotADynamicClass)

RUF052.py:144:5: RUF052 [*] Local dummy variable `_DynamicClass` is accessed
    |
142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
144 |     _DynamicClass = type("_DynamicClass", (), {})
    |     ^^^^^^^^^^^^^ RUF052
145 |     _NotADynamicClass = type("_NotADynamicClass")
    |
    = help: Remove leading underscores

ℹ Unsafe fix
141 141 |     _E = Enum("_E", ["a", "b", "c"])
142 142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
143 143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
144     |-    _DynamicClass = type("_DynamicClass", (), {})
    144 |+    DynamicClass = type("DynamicClass", (), {})
145 145 |     _NotADynamicClass = type("_NotADynamicClass")
146 146 | 
147     |-    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    147 |+    print(_T, _P, _NT, _E, _NT2, _NT3, DynamicClass, _NotADynamicClass)

RUF052.py:145:5: RUF052 [*] Local dummy variable `_NotADynamicClass` is accessed
    |
143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
144 |     _DynamicClass = type("_DynamicClass", (), {})
145 |     _NotADynamicClass = type("_NotADynamicClass")
    |     ^^^^^^^^^^^^^^^^^ RUF052
146 | 
147 |     print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    |
    = help: Remove leading underscores

ℹ Unsafe fix
142 142 |     _NT2 = namedtuple("_NT2", ['x', 'y', 'z'])
143 143 |     _NT3 = namedtuple(typename="_NT3", field_names=['x', 'y', 'z'])
144 144 |     _DynamicClass = type("_DynamicClass", (), {})
145     |-    _NotADynamicClass = type("_NotADynamicClass")
    145 |+    NotADynamicClass = type("_NotADynamicClass")
146 146 | 
147     |-    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, _NotADynamicClass)
    147 |+    print(_T, _P, _NT, _E, _NT2, _NT3, _DynamicClass, NotADynamicClass)
