[ty] support PEP 613 typing.TypeAlias

Author: carljm

crates/ty_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md

@@ -16,7 +16,7 @@ Alias: TypeAlias = int
 
 def f(*args: Unpack[Ts]) -> tuple[Unpack[Ts]]:
     reveal_type(args)  # revealed: tuple[@Todo(`Unpack[]` special form), ...]
-    reveal_type(Alias)  # revealed: @Todo(Support for `typing.TypeAlias`)
+    reveal_type(Alias)  # revealed: Alias
     return args
 
 def g() -> TypeGuard[int]: ...

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -2107,9 +2107,9 @@ reveal_type(False.real)  # revealed: Literal[0]
 All attribute access on literal `bytes` types is currently delegated to `builtins.bytes`:
 
 ```py
-# revealed: bound method Literal[b"foo"].join(iterable_of_bytes: Iterable[@Todo(Support for `typing.TypeAlias`)], /) -> bytes
+# revealed: bound method Literal[b"foo"].join(iterable_of_bytes: Iterable[Buffer], /) -> bytes
 reveal_type(b"foo".join)
-# revealed: bound method Literal[b"foo"].endswith(suffix: @Todo(Support for `typing.TypeAlias`) | tuple[@Todo(Support for `typing.TypeAlias`), ...], start: SupportsIndex | None = ellipsis, end: SupportsIndex | None = ellipsis, /) -> bool
+# revealed: bound method Literal[b"foo"].endswith(suffix: Buffer | tuple[Buffer, ...], start: SupportsIndex | None = ellipsis, end: SupportsIndex | None = ellipsis, /) -> bool
 reveal_type(b"foo".endswith)
 ```
 

crates/ty_python_semantic/resources/mdtest/binary/instances.md

@@ -313,8 +313,7 @@ reveal_type(A() + "foo")  # revealed: A
 reveal_type("foo" + A())  # revealed: A
 
 reveal_type(A() + b"foo")  # revealed: A
-# TODO should be `A` since `bytes.__add__` doesn't support `A` instances
-reveal_type(b"foo" + A())  # revealed: bytes
+reveal_type(b"foo" + A())  # revealed: A
 
 reveal_type(A() + ())  # revealed: A
 reveal_type(() + A())  # revealed: A

crates/ty_python_semantic/resources/mdtest/binary/integers.md

@@ -54,10 +54,8 @@ reveal_type(2**largest_u32)  # revealed: int
 
 def variable(x: int):
     reveal_type(x**2)  # revealed: int
-    # TODO: should be `Any` (overload 5 on `__pow__`), requires correct overload matching
-    reveal_type(2**x)  # revealed: int
-    # TODO: should be `Any` (overload 5 on `__pow__`), requires correct overload matching
-    reveal_type(x**x)  # revealed: int
+    reveal_type(2**x)  # revealed: Any
+    reveal_type(x**x)  # revealed: Any
 ```
 
 If the second argument is \<0, a `float` is returned at runtime. If the first argument is \<0 but

crates/ty_python_semantic/resources/mdtest/expression/lambda.md

@@ -127,7 +127,7 @@ x = lambda y: y
 reveal_type(x.__code__)  # revealed: CodeType
 reveal_type(x.__name__)  # revealed: str
 reveal_type(x.__defaults__)  # revealed: tuple[Any, ...] | None
-reveal_type(x.__annotations__)  # revealed: dict[str, @Todo(Support for `typing.TypeAlias`)]
+reveal_type(x.__annotations__)  # revealed: dict[str, AnnotationForm]
 reveal_type(x.__dict__)  # revealed: dict[str, Any]
 reveal_type(x.__doc__)  # revealed: str | None
 reveal_type(x.__kwdefaults__)  # revealed: dict[str, Any] | None

crates/ty_python_semantic/resources/mdtest/narrow/isinstance.md

@@ -146,13 +146,11 @@ def _(flag: bool):
 def _(flag: bool):
     x = 1 if flag else "a"
 
-    # TODO: this should cause us to emit a diagnostic during
-    # type checking
+    # error: [invalid-argument-type]
     if isinstance(x, "a"):
         reveal_type(x)  # revealed: Literal[1, "a"]
 
-    # TODO: this should cause us to emit a diagnostic during
-    # type checking
+    # error: [invalid-argument-type]
     if isinstance(x, "int"):
         reveal_type(x)  # revealed: Literal[1, "a"]
 ```

crates/ty_python_semantic/resources/mdtest/narrow/issubclass.md

@@ -214,20 +214,13 @@ def flag() -> bool:
 
 t = int if flag() else str
 
-# TODO: this should cause us to emit a diagnostic during
-# type checking
+# error: [invalid-argument-type]
 if issubclass(t, "str"):
     reveal_type(t)  # revealed: <class 'int'> | <class 'str'>
 
-# TODO: this should cause us to emit a diagnostic during
-# type checking
+# TODO error: [invalid-argument-type]
 if issubclass(t, (bytes, "str")):
     reveal_type(t)  # revealed: <class 'int'> | <class 'str'>
-
-# TODO: this should cause us to emit a diagnostic during
-# type checking
-if issubclass(t, Any):
-    reveal_type(t)  # revealed: <class 'int'> | <class 'str'>
 ```
 
 ### Do not narrow if there are keyword arguments

crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md

@@ -0,0 +1,272 @@
+# PEP 613 explicit type aliases
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+Explicit type aliases were introduced in PEP 613. They are defined using an annotated-assignment
+statement, annotated with `typing.TypeAlias`:
+
+## Basic
+
+```py
+from typing import TypeAlias
+
+MyInt: TypeAlias = int
+
+def f(x: MyInt):
+    reveal_type(x)  # revealed: int
+
+f(1)
+```
+
+## Union
+
+For more complex type aliases, such as those involving unions or generics, the inferred value type
+of the right-hand side is not a valid type for use in a type expression, and we need to infer it as
+a type expression.
+
+### Old syntax
+
+```py
+from typing import TypeAlias, Union
+
+IntOrStr: TypeAlias = Union[int, str]
+
+def f(x: IntOrStr):
+    reveal_type(x)  # revealed: int | str
+    if isinstance(x, int):
+        reveal_type(x)  # revealed: int
+    else:
+        reveal_type(x)  # revealed: str
+
+f(1)
+f("foo")
+```
+
+### New syntax
+
+```py
+from typing import TypeAlias
+
+IntOrStr: TypeAlias = int | str
+
+def f(x: IntOrStr):
+    reveal_type(x)  # revealed: int | str
+    if isinstance(x, int):
+        reveal_type(x)  # revealed: int
+    else:
+        reveal_type(x)  # revealed: str
+
+f(1)
+f("foo")
+```
+
+### Name resolution is not deferred
+
+Unlike with a PEP 695 type alias, the right-hand side of a PEP 613 type alias is evaluated
+immediately, name resolution is not deferred.
+
+```py
+from typing import TypeAlias
+
+A: TypeAlias = B | None  # error: [unresolved-reference]
+B: TypeAlias = int
+
+def _(a: A):
+    reveal_type(a)  # revealed: Unknown | None
+```
+
+## Multiple layers of union aliases
+
+```py
+from typing import TypeAlias
+
+class A: ...
+class B: ...
+class C: ...
+class D: ...
+
+W: TypeAlias = A | B
+X: TypeAlias = C | D
+Y: TypeAlias = W | X
+
+from ty_extensions import is_equivalent_to, static_assert
+
+static_assert(is_equivalent_to(Y, A | B | C | D))
+```
+
+## Cycles
+
+We also support cyclic type aliases:
+
+### Old syntax
+
+```py
+from typing import Union, TypeAlias
+
+MiniJSON: TypeAlias = Union[int, str, list["MiniJSON"]]
+
+def f(x: MiniJSON):
+    reveal_type(x)  # revealed: int | str | list[MiniJSON]
+    if isinstance(x, int):
+        reveal_type(x)  # revealed: int
+    elif isinstance(x, str):
+        reveal_type(x)  # revealed: str
+    else:
+        reveal_type(x)  # revealed: list[MiniJSON]
+
+f(1)
+f("foo")
+f([1, "foo"])
+```
+
+### New syntax
+
+```py
+from typing import TypeAlias
+
+MiniJSON: TypeAlias = int | str | list["MiniJSON"]
+
+def f(x: MiniJSON):
+    reveal_type(x)  # revealed: int | str | list[MiniJSON]
+    if isinstance(x, int):
+        reveal_type(x)  # revealed: int
+    elif isinstance(x, str):
+        reveal_type(x)  # revealed: str
+    else:
+        reveal_type(x)  # revealed: list[MiniJSON]
+
+f(1)
+f("foo")
+f([1, "foo"])
+```
+
+### Generic
+
+```py
+from typing import TypeAlias, Generic, TypeVar, Union
+
+T = TypeVar("T")
+
+Alias: TypeAlias = Union[list["Alias"], int]
+
+class A(Generic[T]):
+    pass
+
+class B(A[Alias]):
+    pass
+```
+
+### Mutually recursive
+
+```py
+from typing import TypeAlias
+
+A: TypeAlias = tuple["B"] | None
+B: TypeAlias = tuple[A] | None
+
+def f(x: A):
+    if x is not None:
+        reveal_type(x)  # revealed: tuple[B]
+        y = x[0]
+        if y is not None:
+            reveal_type(y)  # revealed: tuple[A]
+
+def g(x: A | B):
+    reveal_type(x)  # revealed: tuple[B] | None
+
+from ty_extensions import Intersection
+
+def h(x: Intersection[A, B]):
+    reveal_type(x)  # revealed: tuple[B] | None
+```
+
+### Self-recursive callable type
+
+```py
+from typing import Callable, TypeAlias
+
+C: TypeAlias = Callable[[], "C" | None]
+
+def _(x: C):
+    reveal_type(x)  # revealed: () -> C | None
+```
+
+### Union inside generic
+
+#### With old-style union
+
+```py
+from typing import Union, TypeAlias
+
+A: TypeAlias = list[Union["A", str]]
+
+def f(x: A):
+    reveal_type(x)  # revealed: list[A | str]
+    for item in x:
+        reveal_type(item)  # revealed: list[A | str] | str
+```
+
+#### With new-style union
+
+```py
+from typing import TypeAlias
+
+A: TypeAlias = list["A" | str]
+
+def f(x: A):
+    reveal_type(x)  # revealed: list[A | str]
+    for item in x:
+        reveal_type(item)  # revealed: list[A | str] | str
+```
+
+#### With Optional
+
+```py
+from typing import Optional, Union, TypeAlias
+
+A: TypeAlias = list[Optional[Union["A", str]]]
+
+def f(x: A):
+    reveal_type(x)  # revealed: list[A | str | None]
+    for item in x:
+        reveal_type(item)  # revealed: list[A | str | None] | str | None
+```
+
+### Invalid examples
+
+#### No value
+
+```py
+from typing import TypeAlias
+
+# TODO: error
+Bad: TypeAlias
+
+# Nested function so we don't emit unresolved-reference for `Bad`:
+def _():
+    def f(x: Bad):
+        reveal_type(x)  # revealed: Unknown
+```
+
+#### No value, in stub
+
+`stub.pyi`:
+
+```pyi
+from typing import TypeAlias
+
+# TODO: error
+Bad: TypeAlias
+```
+
+`main.py`:
+
+```py
+from stub import Bad
+
+def f(x: Bad):
+    reveal_type(x)  # revealed: Unknown
+```

crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -28,7 +28,7 @@ def f() -> None:
 ```py
 type IntOrStr = int | str
 
-reveal_type(IntOrStr.__value__)  # revealed: @Todo(Support for `typing.TypeAlias`)
+reveal_type(IntOrStr.__value__)  # revealed: Any
 ```
 
 ## Invalid assignment

crates/ty_python_semantic/resources/mdtest/protocols.md

@@ -267,7 +267,9 @@ def f(
 Nonetheless, `Protocol` can still be used as the second argument to `issubclass()` at runtime:
 
 ```py
+# TODO should not error
 # Could also be `Literal[True]`, but `bool` is fine:
+# error: [invalid-argument-type]
 reveal_type(issubclass(MyProtocol, Protocol))  # revealed: bool
 ```