Handle dotted alias imports to check for implicit imports

crates/ruff/resources/test/fixtures/flake8_type_checking/strict.py

@@ -55,3 +55,41 @@ def f():
 
     def test(value: A):
         return pkg.B()
+
+
+def f():
+    # In un-strict mode, this shouldn't rase an error, since `pkg.bar` is used at runtime.
+    import pkg
+    import pkg.bar as B
+
+    def test(value: pkg.A):
+        return B()
+
+
+def f():
+    # In un-strict mode, this shouldn't rase an error, since `pkg.foo.bar` is used at runtime.
+    import pkg.foo as F
+    import pkg.foo.bar as B
+
+    def test(value: F.Foo):
+        return B()
+
+
+def f():
+    # In un-strict mode, this shouldn't rase an error, since `pkg.foo.bar` is used at runtime.
+    import pkg
+    import pkg.foo.bar as B
+
+    def test(value: pkg.A):
+        return B()
+
+
+def f():
+    # In un-strict mode, this _should_ rase an error, since `pkgfoo.bar` is used at runtime.
+    # Note that `pkg` is a prefix of `pkgfoo` which are both different modules. This is
+    # testing the implementation.
+    import pkg
+    import pkgfoo.bar as B
+
+    def test(value: pkg.A):
+        return B()

crates/ruff/src/rules/flake8_type_checking/rules/typing_only_runtime_import.rs

@@ -181,9 +181,20 @@ fn is_implicit_import(this: &Binding, that: &Binding) -> bool {
             }
             BindingKind::Importation(Importation {
                 full_name: that_name,
-                ..
-            })
-            | BindingKind::SubmoduleImportation(SubmoduleImportation {
+                name: that_alias,
+            }) => {
+                if that_name == that_alias {
+                    // Ex) `pkg` vs. `pkg`
+                    this_name == that_name
+                } else {
+                    // Submodule importation with an alias: `import pkg.A as B`
+                    this_name
+                        .split('.')
+                        .zip(that_name.split('.'))
+                        .all(|(this_part, that_part)| this_part == that_part)
+                }
+            }
+            BindingKind::SubmoduleImportation(SubmoduleImportation {
                 name: that_name, ..
             }) => {
                 // Ex) `pkg.A` vs. `pkg.B`

crates/ruff/src/rules/flake8_type_checking/snapshots/ruff__rules__flake8_type_checking__tests__strict.snap

@@ -31,4 +31,40 @@ strict.py:54:25: TCH002 Move third-party import `pkg.bar.A` into a type-checking
 58 |     def test(value: A):
    |
 
+strict.py:62:12: TCH002 Move third-party import `pkg` into a type-checking block
+   |
+62 | def f():
+63 |     # In un-strict mode, this shouldn't rase an error, since `pkg.bar` is used at runtime.
+64 |     import pkg
+   |            ^^^ TCH002
+65 |     import pkg.bar as B
+   |
+
+strict.py:71:12: TCH002 Move third-party import `pkg.foo` into a type-checking block
+   |
+71 | def f():
+72 |     # In un-strict mode, this shouldn't rase an error, since `pkg.foo.bar` is used at runtime.
+73 |     import pkg.foo as F
+   |            ^^^^^^^^^^^^ TCH002
+74 |     import pkg.foo.bar as B
+   |
+
+strict.py:80:12: TCH002 Move third-party import `pkg` into a type-checking block
+   |
+80 | def f():
+81 |     # In un-strict mode, this shouldn't rase an error, since `pkg.foo.bar` is used at runtime.
+82 |     import pkg
+   |            ^^^ TCH002
+83 |     import pkg.foo.bar as B
+   |
+
+strict.py:91:12: TCH002 Move third-party import `pkg` into a type-checking block
+   |
+91 |     # Note that `pkg` is a prefix of `pkgfoo` which are both different modules. This is
+92 |     # testing the implementation.
+93 |     import pkg
+   |            ^^^ TCH002
+94 |     import pkgfoo.bar as B
+   |
+
 

crates/ruff/src/rules/flake8_type_checking/snapshots/ruff__rules__flake8_type_checking__tests__typing-only-third-party-import_strict.py.snap

@@ -11,4 +11,13 @@ strict.py:54:25: TCH002 Move third-party import `pkg.bar.A` into a type-checking
 58 |     def test(value: A):
    |
 
+strict.py:91:12: TCH002 Move third-party import `pkg` into a type-checking block
+   |
+91 |     # Note that `pkg` is a prefix of `pkgfoo` which are both different modules. This is
+92 |     # testing the implementation.
+93 |     import pkg
+   |            ^^^ TCH002
+94 |     import pkgfoo.bar as B
+   |
+