Use parse_parenthesized_expression_range in red-knot

crates/red_knot_python_semantic/resources/mdtest/annotations/string.md

@@ -173,3 +173,27 @@ p: "call()"
 r: "[1, 2]"
 s: "(1, 2)"
 ```
+
+## Multi line annotation
+
+Quoted type annotations should be parsed as if surrounded by parentheses.
+
+```py
+def f(
+    a1: """Literal[None]""",
+    a2: """(Literal[None])""",
+    a3: """(
+      int |
+      str
+  )
+  """,
+    a4: """
+     int |
+       str
+  """,
+):
+    reveal_type(a1)  # revealed: None
+    reveal_type(a2)  # revealed: None
+    reveal_type(a3)  # revealed: int | str
+    reveal_type(a4)  # revealed: int | str
+```

crates/red_knot_python_semantic/src/types/string_annotation.rs

@@ -1,7 +1,7 @@
 use ruff_db::source::source_text;
 use ruff_python_ast::str::raw_contents;
 use ruff_python_ast::{self as ast, ModExpression, StringFlags};
-use ruff_python_parser::{parse_expression_range, Parsed};
+use ruff_python_parser::{parse_parenthesized_expression_range, Parsed};
 use ruff_text_size::Ranged;
 
 use crate::declare_lint;
@@ -165,7 +165,7 @@ pub(crate) fn parse_string_annotation(
             //     | float
             // """ = 1
             // ```
-            match parse_expression_range(source.as_str(), range_excluding_quotes) {
+            match parse_parenthesized_expression_range(source.as_str(), range_excluding_quotes) {
                 Ok(parsed) => return Some(parsed),
                 Err(parse_error) => context.report_lint(
                     &INVALID_SYNTAX_IN_FORWARD_ANNOTATION,

crates/ruff_linter/resources/test/fixtures/pyflakes/F722.py

@@ -16,13 +16,11 @@ def g() -> "///":
 
    int |
    str
-
 """
 
 z: """(
 
     int |
     str
-
 )
 """

crates/ruff_python_parser/src/lib.rs

@@ -166,6 +166,20 @@ pub fn parse_expression_range(
         .into_result()
 }
 
+/// Parses a Python expression as if it is parenthesized.
+///
+/// It behaves similarly to [`parse_expression_range`] but allows what would be valid within parenthesis
+///
+/// # Example
+///
+/// Parsing a parenthesized expression from a larger expression:
+///
+/// ```
+/// use ruff_python_parser::parse_parenthesized_expression_range;
+/// # use ruff_text_size::{TextRange, TextSize};
+///
+/// let parsed = parse_parenthesized_expression_range("\n int | str", TextRange::new(TextSize::new(4), TextSize::new(11)));
+/// assert!(parsed.is_ok());
 pub fn parse_parenthesized_expression_range(
     source: &str,
     range: TextRange,