[flake8_pyi] Fix PYI041 not resolving string annotations

Author: robsdedude

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

@@ -0,0 +1,112 @@
+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

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

@@ -538,6 +538,26 @@ impl<'a> Checker<'a> {
         }
     }
 
+    /// Apply a mapper function to an annotation expression,
+    /// 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<T>(
+        &self,
+        expr: &ast::Expr,
+        map_fn: impl FnOnce(&ast::Expr) -> T,
+    ) -> T {
+        if let ast::Expr::StringLiteral(string_annotation) = expr {
+            let Some(parsed_annotation) = self.parse_type_annotation(string_annotation).ok() else {
+                return map_fn(expr);
+            };
+            map_fn(parsed_annotation.expression())
+        } else {
+            map_fn(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,7 @@ 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::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,13 @@ 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);
+        checker.map_maybe_stringized_annotation(annotation, |resolved_annotation| {
+            check_annotation(checker, resolved_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,8 +143,14 @@ fn check_annotation<'a>(checker: &Checker, annotation: &'a Expr) {
         return;
     }
 
+    let string_annotation = unresolved_annotation
+        .as_string_literal_expr()
+        .map(|str| str.value.to_str());
+
     // Mark [`Fix`] as unsafe when comments are in range.
-    let applicability = if checker.comment_ranges().intersects(annotation.range()) {
+    let applicability = if string_annotation.is_some_and(|s| s.contains('#'))
+        || checker.comment_ranges().intersects(annotation.range())
+    {
         Applicability::Unsafe
     } else {
         Applicability::Safe