TCH003: Fix false positive for singledispatchmethod

crates/ruff_linter/resources/test/fixtures/flake8_type_checking/singledispatchmethod.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from collections.abc import MutableMapping, Mapping
+from pathlib import Path
+from functools import singledispatchmethod
+from typing import Union
+
+
+class Foo:
+    @singledispatchmethod
+    def foo(self, x: Union[MutableMapping, Mapping]) -> int:
+        raise NotImplementedError
+
+    @foo.register
+    def _(self, x: MutableMapping) -> int:
+        return 0
+
+    @foo.register
+    def _(self, x: Mapping) -> int:
+        return 0
+
+
+class Foo2:
+
+    @singledispatchmethod
+    def process_path(self, a: Union[int, str]) -> int:
+        """Convert arg to array or leaves it as sparse matrix."""
+        msg = f"Unhandled type {type(a)}"
+        raise NotImplementedError(msg)
+
+
+    @process_path.register
+    def _(self, a: int) -> int:
+        return a
+
+
+    @process_path.register
+    def _(self, a: str) -> int:
+        return len(a)
+
+
+    def _(self, p: Path) -> Path:
+        return p

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

@@ -141,7 +141,7 @@ pub(crate) fn is_dataclass_meta_annotation(annotation: &Expr, semantic: &Semanti
     false
 }
 
-/// Returns `true` if a function is registered as a `singledispatch` interface.
+/// Returns `true` if a function is registered as a `singledispatch` or `singledispatchmethod` interface.
 ///
 /// For example, `fun` below is a `singledispatch` interface:
 /// ```python
@@ -160,15 +160,17 @@ pub(crate) fn is_singledispatch_interface(
         semantic
             .resolve_qualified_name(&decorator.expression)
             .is_some_and(|qualified_name| {
-                matches!(qualified_name.segments(), ["functools", "singledispatch"])
+                matches!(
+                    qualified_name.segments(),
+                    ["functools", "singledispatch" | "singledispatchmethod"]
+                )
             })
     })
 }
 
-/// Returns `true` if a function is registered as a `singledispatch` implementation.
+/// Returns `true` if a function is registered as a `singledispatch` or `singledispatchmethod` implementation.
 ///
 /// For example, `_` below is a `singledispatch` implementation:
-/// For example:
 /// ```python
 /// from functools import singledispatch
 ///

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

@@ -42,6 +42,10 @@ mod tests {
     #[test_case(Rule::TypingOnlyStandardLibraryImport, Path::new("init_var.py"))]
     #[test_case(Rule::TypingOnlyStandardLibraryImport, Path::new("kw_only.py"))]
     #[test_case(Rule::TypingOnlyStandardLibraryImport, Path::new("snapshot.py"))]
+    #[test_case(
+        Rule::TypingOnlyStandardLibraryImport,
+        Path::new("singledispatchmethod.py")
+    )]
     #[test_case(Rule::TypingOnlyThirdPartyImport, Path::new("TCH002.py"))]
     #[test_case(Rule::TypingOnlyThirdPartyImport, Path::new("quote.py"))]
     #[test_case(Rule::TypingOnlyThirdPartyImport, Path::new("singledispatch.py"))]

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__typing-only-standard-library-import_singledispatchmethod.py.snap

@@ -0,0 +1,27 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+singledispatchmethod.py:4:21: TCH003 [*] Move standard library import `pathlib.Path` into a type-checking block
+  |
+3 | from collections.abc import MutableMapping, Mapping
+4 | from pathlib import Path
+  |                     ^^^^ TCH003
+5 | from functools import singledispatchmethod
+6 | from typing import Union
+  |
+  = help: Move into type-checking block
+
+ℹ Unsafe fix
+1 1 | from __future__ import annotations
+2 2 | 
+3 3 | from collections.abc import MutableMapping, Mapping
+4   |-from pathlib import Path
+5 4 | from functools import singledispatchmethod
+6   |-from typing import Union
+  5 |+from typing import Union, TYPE_CHECKING
+  6 |+
+  7 |+if TYPE_CHECKING:
+  8 |+    from pathlib import Path
+7 9 | 
+8 10 | 
+9 11 | class Foo: