[flake8-type-checking] Avoid TC004 false positives for submodules

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

@@ -517,6 +517,56 @@ mod tests {
     ",
         "tc010_precedence_over_tc008"
     )]
+    #[test_case(
+        r"
+        from __future__ import annotations
+
+        import importlib.abc
+        from typing import TYPE_CHECKING
+
+        if TYPE_CHECKING:
+            import importlib.machinery
+
+        class Foo(importlib.abc.MetaPathFinder):
+            def bar(self) -> importlib.machinery.ModuleSpec: ...
+    ",
+        "github_issue_15723_regression_test"
+    )]
+    // FIXME: Currently whether or not we emit a TC004 for importlib.abc
+    //        depends on the order of the two overlapping imports, however
+    //        fixing this is not trivial, since we would need to group the
+    //        overlapping bindings together, combine their references and
+    //        for each reference check which binding it should belong to
+    #[test_case(
+        r"
+        from __future__ import annotations
+
+        from typing import TYPE_CHECKING
+
+        if TYPE_CHECKING:
+            import importlib.abc
+            import importlib.machinery
+
+        class Foo(importlib.abc.MetaPathFinder):
+            def bar(self) -> importlib.machinery.ModuleSpec: ...
+    ",
+        "github_issue_15723_false_negative"
+    )]
+    #[test_case(
+        r"
+        from __future__ import annotations
+
+        from typing import TYPE_CHECKING
+
+        if TYPE_CHECKING:
+            import importlib.machinery
+            import importlib.abc
+
+        class Foo(importlib.abc.MetaPathFinder):
+            def bar(self) -> importlib.machinery.ModuleSpec: ...
+    ",
+        "github_issue_15723_ideal_import_order"
+    )]
     fn contents(contents: &str, snapshot: &str) {
         let diagnostics = test_snippet(
             contents,

crates/ruff_linter/src/rules/flake8_type_checking/rules/runtime_import_in_type_checking_block.rs

@@ -5,6 +5,7 @@ use rustc_hash::FxHashMap;
 
 use ruff_diagnostics::{Diagnostic, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
+use ruff_python_ast::{self as ast, Expr};
 use ruff_python_semantic::{Imported, NodeId, Scope, ScopeId};
 use ruff_text_size::Ranged;
 
@@ -110,7 +111,7 @@ pub(crate) fn runtime_import_in_type_checking_block(checker: &Checker, scope: &S
         .lookup_symbol_in_scope("__getattr__", ScopeId::global(), false)
         .is_some();
 
-    for binding_id in scope.binding_ids() {
+    for (_, binding_id) in scope.all_bindings() {
         let binding = checker.semantic().binding(binding_id);
 
         let Some(import) = binding.as_any_import() else {
@@ -124,9 +125,45 @@ pub(crate) fn runtime_import_in_type_checking_block(checker: &Checker, scope: &S
         if binding.context.is_typing()
             && binding.references().any(|reference_id| {
                 let reference = checker.semantic().reference(reference_id);
+                if reference.in_typing_context() {
+                    return false;
+                }
+
+                if ignore_dunder_all_references && reference.in_dunder_all_definition() {
+                    return false;
+                }
+
+                // for submodule imports we need to check if the reference
+                // actually refers to this submodule, or a different one
+                let Some(submodule_import) = import.as_submodule_import() else {
+                    return true;
+                };
 
-                reference.in_runtime_context()
-                    && !(ignore_dunder_all_references && reference.in_dunder_all_definition())
+                let Some(expression_id) = reference.expression_id() else {
+                    return false;
+                };
+                // references should generally point towards an `Expr::Name` node
+                // so by walking the parent expressions in tandem with the segments
+                // of the qualified name should give us a `starts_with` check for
+                // the reference towards the import
+                for (segment, expr) in std::iter::zip(
+                    submodule_import.qualified_name().segments(),
+                    checker.semantic().expressions(expression_id),
+                )
+                // we discard the first pair, since it's guaranteed to match
+                // this also simplifies the loop logic, since we only have to
+                // handle `Expr::Attribute` nodes
+                .skip(1)
+                {
+                    let Expr::Attribute(ast::ExprAttribute { attr, .. }) = expr else {
+                        // we're past the attribute nodes, so we can stop
+                        break;
+                    };
+                    if *segment != attr.as_str() {
+                        return false;
+                    }
+                }
+                true
             })
         {
             let Some(node_id) = binding.source else {

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__github_issue_15723_false_negative.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__github_issue_15723_ideal_import_order.snap

@@ -0,0 +1,26 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+<filename>:8:12: TC004 [*] Move import `importlib.abc` out of type-checking block. Import is used for more than type hinting.
+   |
+ 6 | if TYPE_CHECKING:
+ 7 |     import importlib.machinery
+ 8 |     import importlib.abc
+   |            ^^^^^^^^^^^^^ TC004
+ 9 |
+10 | class Foo(importlib.abc.MetaPathFinder):
+   |
+   = help: Move out of type-checking block
+
+ℹ Unsafe fix
+2 2 | from __future__ import annotations
+3 3 | 
+4 4 | from typing import TYPE_CHECKING
+  5 |+import importlib.abc
+5 6 | 
+6 7 | if TYPE_CHECKING:
+7 8 |     import importlib.machinery
+8   |-    import importlib.abc
+9 9 | 
+10 10 | class Foo(importlib.abc.MetaPathFinder):
+11 11 |     def bar(self) -> importlib.machinery.ModuleSpec: ...

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__github_issue_15723_regression_test.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+