Add tests for string annotations

Author: dhruvmanila

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

@@ -1,9 +1,223 @@
 # String annotations
 
+## Simple
+
 ```py
 def f() -> "int":
     return 1
 
-# TODO: We do not support string annotations, but we should not panic if we encounter them
-reveal_type(f())  # revealed: @Todo
+reveal_type(f())  # revealed: int
+```
+
+## Nested
+
+```py
+def f() -> "'int'":
+    return 1
+
+reveal_type(f())  # revealed: int
+```
+
+## Type expression
+
+```py
+def f1() -> "int | str":
+    return 1
+
+
+def f2() -> "tuple[int, str]":
+    return 1
+
+
+reveal_type(f1())  # revealed: int | str
+reveal_type(f2())  # revealed: tuple[int, str]
+```
+
+## Partial
+
+```py
+def f() -> tuple[int, "str"]:
+    return 1
+
+reveal_type(f())  # revealed: tuple[int, str]
+```
+
+## Deferred
+
+```py
+def f() -> "Foo":
+    return Foo()
+
+
+class Foo:
+    pass
+
+
+reveal_type(f())  # revealed: Foo
 ```
+
+## Deferred (undefined)
+
+```py
+# error: [unresolved-reference]
+def f() -> "Foo":
+    pass
+
+
+reveal_type(f())  # revealed: Unknown
+```
+
+## Partial deferred
+
+```py
+def f() -> int | "Foo":
+    return 1
+
+
+class Foo:
+    pass
+
+
+reveal_type(f())  # revealed: int | Foo
+```
+
+## `typing.Literal`
+
+```py
+from typing import Literal
+
+
+def f1() -> Literal["Foo", "Bar"]:
+    return "Foo"
+
+
+def f2() -> 'Literal["Foo", "Bar"]':
+    return "Foo"
+
+
+class Foo:
+    pass
+
+
+reveal_type(f1())  # revealed: Literal["Foo", "Bar"]
+reveal_type(f2())  # revealed: Literal["Foo", "Bar"]
+```
+
+## Various string kinds
+
+```py
+# error: [annotation-raw-string] "Type expressions cannot use raw string literal"
+def f1() -> r"int":
+    return 1
+
+
+# error: [annotation-f-string] "Type expressions cannot use f-strings"
+def f2() -> f"int":
+    return 1
+
+
+# error: [annotation-byte-string] "Type expressions cannot use bytes literal"
+def f3() -> b"int":
+    return 1
+
+
+def f4() -> "int":
+    return 1
+
+
+# error: [annotation-implicit-concat] "Type expressions cannot span multiple string literals"
+def f5() -> "in" "t":
+    return 1
+
+
+# error: [annotation-escape-character] "Type expressions cannot contain escape characters"
+def f6() -> "\N{LATIN SMALL LETTER I}nt":
+    return 1
+
+
+# error: [annotation-escape-character] "Type expressions cannot contain escape characters"
+def f7() -> "\x69nt":
+    return 1
+
+
+def f8() -> """int""":
+    return 1
+
+
+# error: [annotation-byte-string] "Type expressions cannot use bytes literal"
+def f9() -> "b'int'":
+    return 1
+
+
+def f10() -> u"int":
+    return 1
+
+
+reveal_type(f1())  # revealed: Unknown
+reveal_type(f2())  # revealed: Unknown
+reveal_type(f3())  # revealed: Unknown
+reveal_type(f4())  # revealed: int
+reveal_type(f5())  # revealed: Unknown
+reveal_type(f6())  # revealed: Unknown
+reveal_type(f7())  # revealed: Unknown
+reveal_type(f8())  # revealed: int
+reveal_type(f9())  # revealed: Unknown
+reveal_type(f10())  # revealed: int
+```
+
+## Various string kinds in `typing.Literal`
+
+```py
+from typing import Literal
+
+
+def f() -> Literal["a", r"b", b"c", "d" "e", "\N{LATIN SMALL LETTER F}", "\x67", """h""", u"i"]:
+    return "normal"
+
+
+reveal_type(f())  # revealed: Literal["a", "b", "de", "f", "g", "h", "i"] | Literal[b"c"]
+```
+
+## Class variables
+
+```py
+MyType = int
+
+
+class Aliases:
+    MyType = str
+
+    forward: "MyType"
+    not_forward: MyType
+
+
+reveal_type(Aliases.forward)  # revealed: str
+reveal_type(Aliases.not_forward)  # revealed: str
+```
+
+## Annotated assignment
+
+```py
+a: "int" = 1
+b: "'int'" = 1
+c: "Foo"
+# error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to `Foo`"
+d: "Foo" = 1
+
+
+class Foo:
+    pass
+
+
+c = Foo()
+
+reveal_type(a)  # revealed: Literal[1]
+reveal_type(b)  # revealed: Literal[1]
+reveal_type(c)  # revealed: Foo
+reveal_type(d)  # revealed: Foo
+```
+
+## Parameter
+
+TODO: Add tests once parameter inference is supported
+

crates/red_knot_python_semantic/src/types/infer.rs

@@ -4103,6 +4103,24 @@ impl<'db> TypeInferenceBuilder<'db> {
             // Annotation expressions also get special handling for `*args` and `**kwargs`.
             ast::Expr::Starred(starred) => self.infer_starred_expression(starred),
 
+            ast::Expr::BytesLiteral(bytes) => {
+                self.diagnostics.add(
+                    bytes.into(),
+                    "annotation-byte-string",
+                    format_args!("Type expressions cannot use bytes literal"),
+                );
+                Type::Unknown
+            }
+
+            ast::Expr::FString(fstring) => {
+                self.diagnostics.add(
+                    fstring.into(),
+                    "annotation-f-string",
+                    format_args!("Type expressions cannot use f-strings"),
+                );
+                Type::Unknown
+            }
+
             // All other annotation expressions are (possibly) valid type expressions, so handle
             // them there instead.
             type_expr => self.infer_type_expression_no_store(type_expr),

crates/red_knot_python_semantic/src/types/string_annotation.rs

@@ -11,10 +11,6 @@ use crate::Db;
 type AnnotationParseResult = Result<Parsed<ModExpression>, TypeCheckDiagnostics>;
 
 /// Parses the given expression as a string annotation.
-///
-/// # Panics
-///
-/// Panics if the expression is not a string literal.
 pub(crate) fn parse_string_annotation(
     db: &dyn Db,
     file: File,
@@ -32,20 +28,25 @@ pub(crate) fn parse_string_annotation(
             diagnostics.add(
                 string_literal.into(),
                 "annotation-raw-string",
-                format_args!("Type expressions cannot be use raw string literal"),
+                format_args!("Type expressions cannot use raw string literal"),
             );
-        }
-
         // Compare the raw contents (without quotes) of the expression with the parsed contents
         // contained in the string literal.
-        if raw_contents(node_text)
+        } else if raw_contents(node_text)
             .is_some_and(|raw_contents| raw_contents == string_literal.as_str())
         {
             let range_excluding_quotes = string_literal
                 .range()
                 .add_start(string_literal.flags.opener_len())
                 .sub_end(string_literal.flags.closer_len());
 
+            // TODO: Support multiline strings like:
+            // ```py
+            // x: """
+            //     int
+            //     | float
+            // """ = 1
+            // ```
             match parse_expression_range(source.as_str(), range_excluding_quotes) {
                 Ok(parsed) => return Ok(parsed),
                 Err(parse_error) => diagnostics.add(