[flake8-pyi] Fix PYI041 not resolving string annotations

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI041_3.py

@@ -0,0 +1,137 @@
+from typing import (
+    TYPE_CHECKING,
+    Union,
+)
+
+from typing_extensions import (
+    TypeAlias,
+)
+
+TA0: TypeAlias = "int"
+TA1: TypeAlias = "int | float | bool"
+TA2: TypeAlias = "Union[int, float, bool]"
+
+
+def good1(arg: "int") -> "int | bool":
+    ...
+
+
+def good2(arg: "int", arg2: "int | bool") -> "None":
+    ...
+
+
+def f0(arg1: "float | int") -> "None":
+    ...
+
+
+def f1(arg1: "float", *, arg2: "float | list[str] | type[bool] | complex") -> "None":
+    ...
+
+
+def f2(arg1: "int", /, arg2: "int | int | float") -> "None":
+    ...
+
+
+def f3(arg1: "int", *args: "Union[int | int | float]") -> "None":
+    ...
+
+
+async def f4(**kwargs: "int | int | float") -> "None":
+    ...
+
+
+def f5(arg1: "int", *args: "Union[int, int, float]") -> "None":
+    ...
+
+
+def f6(arg1: "int", *args: "Union[Union[int, int, float]]") -> "None":
+    ...
+
+
+def f7(arg1: "int", *args: "Union[Union[Union[int, int, float]]]") -> "None":
+    ...
+
+
+def f8(arg1: "int", *args: "Union[Union[Union[int | int | float]]]") -> "None":
+    ...
+
+
+def f9(
+    arg: """Union[  # comment
+        float, # another
+        complex, int]"""
+    ) -> "None":
+    ...
+
+def f10(
+    arg: """
+        int | # comment
+        float |  # another
+        complex
+    """
+    ) -> "None":
+    ...
+
+
+class Foo:
+    def good(self, arg: "int") -> "None":
+        ...
+
+    def bad(self, arg: "int | float | complex") -> "None":
+        ...
+
+    def bad2(self, arg: "int | Union[float, complex]") -> "None":
+        ...
+
+    def bad3(self, arg: "Union[Union[float, complex], int]") -> "None":
+        ...
+
+    def bad4(self, arg: "Union[float | complex, int]") -> "None":
+        ...
+
+    def bad5(self, arg: "int | (float | complex)") -> "None":
+        ...
+
+
+# https://github.com/astral-sh/ruff/issues/18298
+# fix must not yield runtime `None | None | ...` (TypeError)
+class Issue18298:
+    def f1(self, arg: "None | int | None | float" = None) -> "None":  # PYI041 - no fix
+        pass
+
+    if TYPE_CHECKING:
+
+        def f2(self, arg: "None | int | None | float" = None) -> "None": ...  # PYI041 - with fix
+
+    else:
+
+        def f2(self, arg=None) -> "None":
+            pass
+
+    def f3(self, arg: "None | float | None | int | None" = None) -> "None":  # PYI041 - with fix
+        pass
+
+
+class FooStringConcat:
+    def good(self, arg: "i" "nt") -> "None":
+        ...
+
+    def bad(self, arg: "int " "| float | com" "plex") -> "None":
+        ...
+
+    def bad2(self, arg: "int | Union[flo" "at, complex]") -> "None":
+        ...
+
+    def bad3(self, arg: "Union[Union[float, com" "plex], int]") -> "None":
+        ...
+
+    def bad4(self, arg: "Union[float | complex, in" "t ]") -> "None":
+        ...
+
+    def bad5(self, arg: "int | "
+                        "(float | complex)") -> "None":
+        ...
+
+    def bad6(self, arg: "in\
+t | (float | compl" "ex)") -> "None":
+        ...

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI041_4.py

@@ -0,0 +1,8 @@
+from typing import Union as Uno
+
+
+def f1(a: "U" "no[int, fl" "oat, Foo]") -> "None": ...
+def f2(a: "Uno[int, float, Foo]") -> "None": ...
+def f3(a: """Uno[int, float, Foo]""") -> "None": ...
+def f4(a: "Uno[in\
+t, float, Foo]") -> "None": ...

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -542,6 +542,23 @@ impl<'a> Checker<'a> {
         }
     }
 
+    /// Given a type annotation [`Expr`], abstracting over the fact that the annotation expression
+    /// might be "stringized".
+    ///
+    /// A stringized annotation is one enclosed in string quotes:
+    /// `foo: "typing.Any"` means the same thing to a type checker as `foo: typing.Any`.
+    pub(crate) fn map_maybe_stringized_annotation<'b>(&self, expr: &'b ast::Expr) -> &'b ast::Expr
+    where
+        'a: 'b,
+    {
+        if let ast::Expr::StringLiteral(string_annotation) = expr {
+            if let Ok(parsed_annotation) = self.parse_type_annotation(string_annotation) {
+                return parsed_annotation.expression();
+            }
+        }
+        expr
+    }
+
     /// Push `diagnostic` if the checker is not in a `@no_type_check` context.
     pub(crate) fn report_type_diagnostic<T: Violation>(&self, kind: T, range: TextRange) {
         if !self.semantic.in_no_type_check() {

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

@@ -76,6 +76,8 @@ mod tests {
     #[test_case(Rule::RedundantNumericUnion, Path::new("PYI041_1.py"))]
     #[test_case(Rule::RedundantNumericUnion, Path::new("PYI041_1.pyi"))]
     #[test_case(Rule::RedundantNumericUnion, Path::new("PYI041_2.py"))]
+    #[test_case(Rule::RedundantNumericUnion, Path::new("PYI041_3.py"))]
+    #[test_case(Rule::RedundantNumericUnion, Path::new("PYI041_4.py"))]
     #[test_case(Rule::SnakeCaseTypeAlias, Path::new("PYI042.py"))]
     #[test_case(Rule::SnakeCaseTypeAlias, Path::new("PYI042.pyi"))]
     #[test_case(Rule::StrOrReprDefinedInStub, Path::new("PYI029.py"))]

crates/ruff_linter/src/rules/flake8_pyi/rules/redundant_numeric_union.rs

@@ -80,11 +80,15 @@ impl Violation for RedundantNumericUnion {
 /// PYI041
 pub(crate) fn redundant_numeric_union(checker: &Checker, parameters: &Parameters) {
     for annotation in parameters.iter().filter_map(AnyParameterRef::annotation) {
-        check_annotation(checker, annotation);
+        check_annotation(
+            checker,
+            checker.map_maybe_stringized_annotation(annotation),
+            annotation,
+        );
     }
 }
 
-fn check_annotation<'a>(checker: &Checker, annotation: &'a Expr) {
+fn check_annotation<'a>(checker: &Checker, annotation: &'a Expr, unresolved_annotation: &'a Expr) {
     let mut numeric_flags = NumericFlags::empty();
 
     let mut find_numeric_type = |expr: &Expr, _parent: &Expr| {
@@ -141,12 +145,20 @@ fn check_annotation<'a>(checker: &Checker, annotation: &'a Expr) {
         return;
     }
 
+    let string_annotation = unresolved_annotation.as_string_literal_expr();
+    if string_annotation.is_some_and(|s| s.value.is_implicit_concatenated()) {
+        // No fix for concatenated string literals. They're rare and too complex to handle.
+        // https://github.com/astral-sh/ruff/issues/19184#issuecomment-3047695205
+        return;
+    }
+
     // Mark [`Fix`] as unsafe when comments are in range.
-    let applicability = if checker.comment_ranges().intersects(annotation.range()) {
-        Applicability::Unsafe
-    } else {
-        Applicability::Safe
-    };
+    let applicability =
+        if string_annotation.is_some() || checker.comment_ranges().intersects(annotation.range()) {
+            Applicability::Unsafe
+        } else {
+            Applicability::Safe
+        };
 
     // Generate the flattened fix once.
     let fix = if let &[edit_expr] = necessary_nodes.as_slice() {