[ty] Allow partially stringified type[…] annotations (#24518)

sharkdp · web-flow · commit f518cc9ca0c8 · 2026-04-09T13:16:26.000Z
## Summary Allow partially stringified `type["ForwardRef"]` annotations, even if they are not explicitly allowed by the typing spec. The implementation here follows what we do in e.g. `infer_string_type_expression`. closes astral-sh/ty#3244 ## Ecosystem We apparently get rid of a prevalent `@Todo` type, so we see new diagnostics, but nothing that looks like *new* false positives, related to this change. A lot of ecosystem hits have an ignore-comment for another type checker, which is generally a good signal. ## Test Plan * New Markdown tests * Verified that it fixes the problem in astral-sh/ty#3244
diff --git a/crates/ty_python_semantic/resources/mdtest/narrow/issubclass.md b/crates/ty_python_semantic/resources/mdtest/narrow/issubclass.md
@@ -227,6 +227,7 @@ python-version = "3.9"
 ```
 
 ```py
+# error: [unsupported-operator]
 def _(x: type[int | str | bytes]):
     # error: [unsupported-operator]
     if issubclass(x, int | str):
diff --git a/crates/ty_python_semantic/resources/mdtest/type_of/basic.md b/crates/ty_python_semantic/resources/mdtest/type_of/basic.md
@@ -155,6 +155,91 @@ f(types.NoneType)
 f(None)  # error: [invalid-argument-type]
 ```
 
+## Stringified annotations
+
+### Basic
+
+Stringified and partially stringified `type[…]` annotations are supported, even if the latter are
+not explicitly allowed by the [syntax in the typing spec].
+
+```py
+def _(
+    type_of_foo_1: "type[Foo]",
+    type_of_foo_2: type["Foo"],
+    type_of_foo_or_bar_1: "type[Foo | Bar]",
+    type_of_foo_or_bar_2: type["Foo | Bar"],
+):
+    reveal_type(type_of_foo_1)  # revealed: type[Foo]
+    reveal_type(type_of_foo_2)  # revealed: type[Foo]
+    reveal_type(type_of_foo_or_bar_1)  # revealed: type[Foo | Bar]
+    reveal_type(type_of_foo_or_bar_2)  # revealed: type[Foo | Bar]
+
+class Foo: ...
+class Bar: ...
+```
+
+Illegal stringified annotations lead to a diagnostic:
+
+```py
+# error: [invalid-syntax-in-forward-annotation]
+def _(type_of_invalid: type[""]):
+    reveal_type(type_of_invalid)  # revealed: type[Unknown]
+```
+
+### Unions of strings, Python 3.13
+
+"Unions of strings" lead to a runtime error on 3.13 and lower, so we emit a diagnostic. We still
+infer `type[Foo | Bar]` though, since the intention seems clear.
+
+```toml
+[environment]
+python-version = "3.13"
+```
+
+```py
+def _(type_of_invalid: type["Foo" | "Bar"]):  # error: [unsupported-operator]
+    reveal_type(type_of_invalid)  # revealed: type[Foo | Bar]
+
+class Foo: ...
+class Bar: ...
+```
+
+### Unions of strings, Python 3.13 with `from __future__ import annotations`
+
+On Python 3.13 with `from __future__ import annotations`, there is no error:
+
+```toml
+[environment]
+python-version = "3.13"
+```
+
+```py
+from __future__ import annotations
+
+def _(type_of_foo_or_bar: type["Foo" | "Bar"]):
+    reveal_type(type_of_foo_or_bar)  # revealed: type[Foo | Bar]
+
+class Foo: ...
+class Bar: ...
+```
+
+### Unions of strings, Python 3.14
+
+On Python 3.14 and higher, this is also fine:
+
+```toml
+[environment]
+python-version = "3.14"
+```
+
+```py
+def _(type_of_foo_or_bar: type["Foo" | "Bar"]):
+    reveal_type(type_of_foo_or_bar)  # revealed: type[Foo | Bar]
+
+class Foo: ...
+class Bar: ...
+```
+
 ## Illegal parameters
 
 ```py
@@ -496,3 +581,5 @@ def f(
     reveal_type(c)  # revealed: <class 'Bar'> | (() -> Bar)
     reveal_type(d)  # revealed: CustomCallback
 ```
+
+[syntax in the typing spec]: https://typing.python.org/en/latest/spec/annotations.html#type-and-annotation-expressions
diff --git a/crates/ty_python_semantic/src/types/infer/builder/type_expression.rs b/crates/ty_python_semantic/src/types/infer/builder/type_expression.rs
@@ -1091,18 +1091,11 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
         };
 
         match slice {
-            ast::Expr::Name(_) | ast::Expr::Attribute(_) => infer_type_argument(self, slice),
+            ast::Expr::Name(_) | ast::Expr::Attribute(_) | ast::Expr::StringLiteral(_) => {
+                infer_type_argument(self, slice)
+            }
             ast::Expr::BinOp(binary) if binary.op == ast::Operator::BitOr => {
-                let union_ty = UnionType::from_elements_leave_aliases(
-                    self.db(),
-                    [
-                        self.infer_subclass_of_type_expression(&binary.left),
-                        self.infer_subclass_of_type_expression(&binary.right),
-                    ],
-                );
-                self.store_expression_type(slice, union_ty);
-
-                union_ty
+                infer_type_argument(self, slice)
             }
             ast::Expr::Tuple(_) => {
                 if !self.in_string_annotation() {
@@ -1193,7 +1186,6 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                 self.store_expression_type(slice, parameters_ty);
                 parameters_ty
             }
-            // TODO: subscripts, etc.
             _ => {
                 self.infer_expression(slice, TypeContext::default());
                 todo_type!("unsupported type[X] special form")
