[pylint] Allow dunder submodules and improve diagnostic range (PLC2701) (#22804)

## Summary

This PR addresses two improvements for the `PLC2701`
(`import-private-name`) rule:

1. **Excludes dunder submodules**: Specifically handles the false
positive where `__main__` was being flagged as a private name import. It
now ensures that any segment identified as a "dunder" (starting and
ending with `__`) is ignored by the rule.
2. **Improves diagnostic ranges**: Refines the error highlight to be
more surgical. Instead of pointing to the end of the import binding, the
linter now pinpoint's the exact private segment—whether it's in the
module path (e.g., `from pkg._private import func`) or the imported
member (e.g., `from pkg import _private`).

Closes #22187

## Test Plan

- **Manual Verification**: Verified using a `repro.py` script covering
three scenarios:
    - `from pkg import _private` (Surgical highlight on member)
- `from pkg._private import func` (Surgical highlight on module path)
    - `from pkg.__main__ import func` (Correctly ignored)
- **Snapshot Testing**: Updated existing test snapshots in
`crates/ruff_linter/src/rules/pylint/snapshots/`. The diffs confirm that
diagnostic ranges have shifted from the imported name to the actual
private name causing the violation.

---------

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

Author: Jkhall81

crates/ruff_linter/resources/test/fixtures/pylint/import_private_name/submodule/__main__.py

@@ -44,3 +44,5 @@ class Class:
 
     def __init__(self, arg: vv) -> "zz":
         pass
+
+from foo.    _bar import baz

crates/ruff_linter/src/rules/pylint/rules/import_private_name.rs

@@ -3,8 +3,9 @@ use std::borrow::Cow;
 use itertools::Itertools;
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_ast::name::QualifiedName;
+use ruff_python_ast::{self as ast, helpers::is_dunder, name::QualifiedName};
 use ruff_python_semantic::{FromImport, Import, Imported, ResolvedReference, Scope};
+use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::Ranged;
 
 use crate::Violation;
@@ -96,7 +97,7 @@ pub(crate) fn import_private_name(checker: &Checker, scope: &Scope) {
         // We can also ignore dunder names.
         // Ex) `from __future__ import annotations`
         // Ex) `from foo import __version__`
-        if root_module.starts_with("__") || import_info.member_name.starts_with("__") {
+        if is_dunder(root_module) || is_dunder(&import_info.member_name) {
             continue;
         }
 
@@ -116,7 +117,7 @@ pub(crate) fn import_private_name(checker: &Checker, scope: &Scope) {
             .qualified_name
             .segments()
             .iter()
-            .find_position(|name| name.starts_with('_'))
+            .find_position(|name| name.starts_with('_') && !is_dunder(name))
         else {
             continue;
         };
@@ -137,7 +138,29 @@ pub(crate) fn import_private_name(checker: &Checker, scope: &Scope) {
         } else {
             None
         };
-        checker.report_diagnostic(ImportPrivateName { name, module }, binding.range());
+        let range = match binding.source.map(|id| checker.semantic().statement(id)) {
+            Some(ast::Stmt::ImportFrom(ast::StmtImportFrom { module, names, .. })) => {
+                if index < import_info.module_name.len() {
+                    module.as_ref().map_or(binding.range(), |module| {
+                        SimpleTokenizer::starts_at(module.start(), checker.locator().contents())
+                            .skip_trivia()
+                            .find(|token| {
+                                token.kind == SimpleTokenKind::Name
+                                    && checker.locator().slice(token.range()) == *private_name
+                            })
+                            .map_or(binding.range(), |token| token.range())
+                    })
+                } else {
+                    names
+                        .iter()
+                        .find(|alias| alias.name.as_str() == import_info.member_name)
+                        .map_or(binding.range(), |alias| alias.name.range())
+                }
+            }
+            _ => binding.range(),
+        };
+
+        checker.report_diagnostic(ImportPrivateName { name, module }, range);
     }
 }
 

crates/ruff_linter/src/rules/pylint/snapshots/ruff_linter__rules__pylint__tests__PLC2701_import_private_name__submodule____main__.py.snap

@@ -2,33 +2,33 @@
 source: crates/ruff_linter/src/rules/pylint/mod.rs
 ---
 PLC2701 Private name import `_a`
- --> __main__.py:2:16
+ --> __main__.py:2:6
   |
 1 | # Errors.
 2 | from _a import b
-  |                ^
+  |      ^^
 3 | from c._d import e
 4 | from _f.g import h
   |
 
 PLC2701 Private name import `_d` from external module `c`
- --> __main__.py:3:18
+ --> __main__.py:3:8
   |
 1 | # Errors.
 2 | from _a import b
 3 | from c._d import e
-  |                  ^
+  |        ^^
 4 | from _f.g import h
 5 | from i import _j
   |
 
 PLC2701 Private name import `_f`
- --> __main__.py:4:18
+ --> __main__.py:4:6
   |
 2 | from _a import b
 3 | from c._d import e
 4 | from _f.g import h
-  |                  ^
+  |      ^^
 5 | from i import _j
 6 | from k import _l as m
   |
@@ -45,12 +45,12 @@ PLC2701 Private name import `_j` from external module `i`
   |
 
 PLC2701 Private name import `_l` from external module `k`
- --> __main__.py:6:21
+ --> __main__.py:6:15
   |
 4 | from _f.g import h
 5 | from i import _j
 6 | from k import _l as m
-  |                     ^
+  |               ^^
 7 | import _aaa
 8 | import bbb.ccc._ddd as eee  # Panicked in https://github.com/astral-sh/ruff/pull/5920
   |
@@ -75,3 +75,12 @@ PLC2701 Private name import `_ddd` from external module `bbb.ccc`
  9 |
 10 | # Non-errors.
    |
+
+PLC2701 Private name import `_bar` from external module `foo`
+  --> __main__.py:48:14
+   |
+46 |         pass
+47 |
+48 | from foo.    _bar import baz
+   |              ^^^^
+   |