--- a/crates/ruff_linter/resources/test/fixtures/ruff/RUF052.py
+++ b/crates/ruff_linter/resources/test/fixtures/ruff/RUF052.py
@@ -88,19 +88,39 @@ x = "global"
 
 def fun():
     global x
-    _x = "shadows global" # [RUF052]
+    _x = "shadows global" # [RUF052] (but unfixable)
     return _x
 
 def foo():
   x = "outer"
   def bar():
     nonlocal x
-    _x = "shadows nonlocal" # [RUF052]
+    _x = "shadows nonlocal" # [RUF052] (but unfixable)
     return _x
   bar()
   return x
 
 def fun():
     x = "local"
-    _x = "shadows local" # [RUF052]
+    _x = "shadows local" # [RUF052] (but unfixable)
+    return _x
+
+def fun2():
+    x = "local"
+    x_ = "also local"
+    _x = "shadows local"  # [RUF052] (but unfixable)
     return _x
+
+def fun3():
+    global x_
+    x = "local"
+    _x = "shadows local"  # [RUF052] (but unfixable)
+    return _x
+
+def fun4():
+    x_ = 42
+    def fun5():
+        x = "local"
+        _x = "shadows local"  # RUF052 (but unfixable)
+        print(x_)
+        return _x
diff --git a/crates/ruff_linter/src/rules/ruff/rules/dummy_variable_accessed.rs b/crates/ruff_linter/src/rules/ruff/rules/dummy_variable_accessed.rs
index ca940bde3..e4a8dd28f 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/dummy_variable_accessed.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/dummy_variable_accessed.rs
@@ -1,7 +1,7 @@
-use ruff_diagnostics::{Applicability, Diagnostic, Fix, FixAvailability, Violation};
+use ruff_diagnostics::{Diagnostic, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::helpers::is_dunder;
-use ruff_python_semantic::{Binding, BindingKind, Scope};
+use ruff_python_semantic::{Binding, BindingKind, SemanticModel};
 use ruff_python_stdlib::{
     builtins::is_python_builtin, identifiers::is_identifier, keyword::is_keyword,
 };
@@ -21,6 +21,9 @@ use crate::{checkers::ast::Checker, renamer::Renamer};
 /// the code's intention. A variable marked as "unused" being subsequently used suggests oversight or unintentional use.
 /// This detracts from the clarity and maintainability of the codebase.
 ///
+/// Sometimes leading underscores are used to avoid variables shadowing other variables, Python builtins, or Python
+/// keywords. However, [PEP 8] recommends to use trailing underscores for this rather than leading underscores.
+///
 /// ## Example
 /// ```python
 /// def function():
@@ -40,6 +43,8 @@ use crate::{checkers::ast::Checker, renamer::Renamer};
 ///
 /// ## Options
 /// - [`lint.dummy-variable-rgx`]
+///
+/// [PEP 8]: https://peps.python.org/pep-0008/
 #[derive(ViolationMetadata)]
 pub(crate) struct DummyVariableAccessed {
     name: String,
@@ -96,8 +101,11 @@ pub(crate) fn dummy_variable_accessed(checker: &Checker, binding: &Binding) -> O
     if binding.is_global() || binding.is_nonlocal() {
         return None;
     }
+
+    let semantic = checker.semantic();
+
     // Only variables defined in function scopes
-    let scope = &checker.semantic().scopes[binding.scope];
+    let scope = &semantic.scopes[binding.scope];
     if !scope.kind.is_function() {
         return None;
     }
@@ -105,7 +113,7 @@ pub(crate) fn dummy_variable_accessed(checker: &Checker, binding: &Binding) -> O
         return None;
     }
 
-    let possible_fix_kind = get_possible_fix_kind(name, scope, checker);
+    let possible_fix_kind = get_possible_fix_kind(name, checker);
 
     let mut diagnostic = Diagnostic::new(
         DummyVariableAccessed {
@@ -118,12 +126,10 @@ pub(crate) fn dummy_variable_accessed(checker: &Checker, binding: &Binding) -> O
     // If fix available
     if let Some(fix_kind) = possible_fix_kind {
         // Get the possible fix based on the scope
-        if let Some(fix) = get_possible_fix(name, fix_kind, scope) {
+        if let Some(fix) = get_possible_fix(name, fix_kind, semantic) {
             diagnostic.try_set_fix(|| {
-                let (edit, rest) =
-                    Renamer::rename(name, &fix, scope, checker.semantic(), checker.stylist())?;
-                let applicability = Applicability::Safe;
-                Ok(Fix::applicable_edits(edit, rest, applicability))
+                Renamer::rename(name, &fix, scope, semantic, checker.stylist())
+                    .map(|(edit, rest)| Fix::safe_edits(edit, rest))
             });
         }
     }
@@ -145,7 +151,7 @@ enum ShadowedKind {
 }
 
 /// Suggests a potential alternative name to resolve a shadowing conflict.
-fn get_possible_fix(name: &str, kind: ShadowedKind, scope: &Scope) -> Option<String> {
+fn get_possible_fix(name: &str, kind: ShadowedKind, semantic: &SemanticModel) -> Option<String> {
     // Remove leading underscores for processing
     let trimmed_name = name.trim_start_matches('_');
 
@@ -157,8 +163,8 @@ fn get_possible_fix(name: &str, kind: ShadowedKind, scope: &Scope) -> Option<Str
         ShadowedKind::None => trimmed_name.to_string(),
     };
 
-    // Ensure the fix name is not already taken in the scope
-    if scope.has(&fix_name) {
+    // Ensure the fix name is not already taken in the scope or enclosing scopes
+    if !semantic.is_available(&fix_name) {
         return None;
     }
 
@@ -167,7 +173,7 @@ fn get_possible_fix(name: &str, kind: ShadowedKind, scope: &Scope) -> Option<Str
 }
 
 /// Determines the kind of shadowing or conflict for a given variable name.
-fn get_possible_fix_kind(name: &str, scope: &Scope, checker: &Checker) -> Option<ShadowedKind> {
+fn get_possible_fix_kind(name: &str, checker: &Checker) -> Option<ShadowedKind> {
     // If the name starts with an underscore, we don't consider it
     if !name.starts_with('_') {
         return None;
@@ -189,7 +195,7 @@ fn get_possible_fix_kind(name: &str, scope: &Scope, checker: &Checker) -> Option
         return Some(ShadowedKind::BuiltIn);
     }
 
-    if scope.has(trimmed_name) {
+    if !checker.semantic().is_available(trimmed_name) {
         return Some(ShadowedKind::Some);
     }

diff --git a/crates/ruff_linter/src/rules/ruff/rules/dummy_variable_accessed.rs b/crates/ruff_linter/src/rules/ruff/rules/dummy_variable_accessed.rs
index e4a8dd28f..d90cf4ce5 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/dummy_variable_accessed.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/dummy_variable_accessed.rs
@@ -1,7 +1,7 @@
 use ruff_diagnostics::{Diagnostic, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::helpers::is_dunder;
-use ruff_python_semantic::{Binding, BindingKind, SemanticModel};
+use ruff_python_semantic::{Binding, BindingKind, ScopeId, SemanticModel};
 use ruff_python_stdlib::{
     builtins::is_python_builtin, identifiers::is_identifier, keyword::is_keyword,
 };
@@ -113,7 +113,7 @@ pub(crate) fn dummy_variable_accessed(checker: &Checker, binding: &Binding) -> O
         return None;
     }
 
-    let possible_fix_kind = get_possible_fix_kind(name, checker);
+    let possible_fix_kind = get_possible_fix_kind(name, checker, binding.scope);
 
     let mut diagnostic = Diagnostic::new(
         DummyVariableAccessed {
@@ -126,7 +126,7 @@ pub(crate) fn dummy_variable_accessed(checker: &Checker, binding: &Binding) -> O
     // If fix available
     if let Some(fix_kind) = possible_fix_kind {
         // Get the possible fix based on the scope
-        if let Some(fix) = get_possible_fix(name, fix_kind, semantic) {
+        if let Some(fix) = get_possible_fix(name, fix_kind, binding.scope, semantic) {
             diagnostic.try_set_fix(|| {
                 Renamer::rename(name, &fix, scope, semantic, checker.stylist())
                     .map(|(edit, rest)| Fix::safe_edits(edit, rest))
@@ -151,7 +151,12 @@ enum ShadowedKind {
 }
 
 /// Suggests a potential alternative name to resolve a shadowing conflict.
-fn get_possible_fix(name: &str, kind: ShadowedKind, semantic: &SemanticModel) -> Option<String> {
+fn get_possible_fix(
+    name: &str,
+    kind: ShadowedKind,
+    scope_id: ScopeId,
+    semantic: &SemanticModel,
+) -> Option<String> {
     // Remove leading underscores for processing
     let trimmed_name = name.trim_start_matches('_');
 
@@ -164,7 +169,7 @@ fn get_possible_fix(name: &str, kind: ShadowedKind, semantic: &SemanticModel) ->
     };
 
     // Ensure the fix name is not already taken in the scope or enclosing scopes
-    if !semantic.is_available(&fix_name) {
+    if !semantic.is_available_in_scope(&fix_name, scope_id) {
         return None;
     }
 
@@ -173,7 +178,7 @@ fn get_possible_fix(name: &str, kind: ShadowedKind, semantic: &SemanticModel) ->
 }
 
 /// Determines the kind of shadowing or conflict for a given variable name.
-fn get_possible_fix_kind(name: &str, checker: &Checker) -> Option<ShadowedKind> {
+fn get_possible_fix_kind(name: &str, checker: &Checker, scope_id: ScopeId) -> Option<ShadowedKind> {
     // If the name starts with an underscore, we don't consider it
     if !name.starts_with('_') {
         return None;
@@ -195,7 +200,10 @@ fn get_possible_fix_kind(name: &str, checker: &Checker) -> Option<ShadowedKind>
         return Some(ShadowedKind::BuiltIn);
     }
 
-    if !checker.semantic().is_available(trimmed_name) {
+    if !checker
+        .semantic()
+        .is_available_in_scope(trimmed_name, scope_id)
+    {
         return Some(ShadowedKind::Some);
     }
 
diff --git a/crates/ruff_python_semantic/src/model.rs b/crates/ruff_python_semantic/src/model.rs
index 9be76dc20..ff3a1a10a 100644
--- a/crates/ruff_python_semantic/src/model.rs
+++ b/crates/ruff_python_semantic/src/model.rs
@@ -325,9 +325,15 @@ impl<'a> SemanticModel<'a> {
     }
 
     /// Return `true` if `member` is an "available" symbol, i.e., a symbol that has not been bound
-    /// in the current scope, or in any containing scope.
+    /// in the current scope currently being visited, or in any containing scope.
     pub fn is_available(&self, member: &str) -> bool {
-        self.lookup_symbol(member)
+        self.is_available_in_scope(member, self.scope_id)
+    }
+
+    /// Return `true` if `member` is an "available" symbol in a given scope, i.e.,
+    /// a symbol that has not been bound in that current scope, or in any containing scope.
+    pub fn is_available_in_scope(&self, member: &str, scope_id: ScopeId) -> bool {
+        self.lookup_symbol_in_scope(member, scope_id, false)
             .map(|binding_id| &self.bindings[binding_id])
             .map_or(true, |binding| binding.kind.is_builtin())
     }
@@ -620,10 +626,22 @@ impl<'a> SemanticModel<'a> {
         }
     }
 
-    /// Lookup a symbol in the current scope. This is a carbon copy of [`Self::resolve_load`], but
-    /// doesn't add any read references to the resolved symbol.
+    /// Lookup a symbol in the current scope.
     pub fn lookup_symbol(&self, symbol: &str) -> Option<BindingId> {
-        if self.in_forward_reference() {
+        self.lookup_symbol_in_scope(symbol, self.scope_id, self.in_forward_reference())
+    }
+
+    /// Lookup a symbol in a certain scope
+    ///
+    /// This is a carbon copy of [`Self::resolve_load`], but
+    /// doesn't add any read references to the resolved symbol.
+    pub fn lookup_symbol_in_scope(
+        &self,
+        symbol: &str,
+        scope_id: ScopeId,
+        in_forward_reference: bool,
+    ) -> Option<BindingId> {
+        if in_forward_reference {
             if let Some(binding_id) = self.scopes.global().get(symbol) {
                 if !self.bindings[binding_id].is_unbound() {
                     return Some(binding_id);
@@ -633,7 +651,7 @@ impl<'a> SemanticModel<'a> {
 
         let mut seen_function = false;
         let mut class_variables_visible = true;
-        for (index, scope_id) in self.scopes.ancestor_ids(self.scope_id).enumerate() {
+        for (index, scope_id) in self.scopes.ancestor_ids(scope_id).enumerate() {
             let scope = &self.scopes[scope_id];
             if scope.kind.is_class() {
                 if seen_function && matches!(symbol, "__class__") {