Fix various overflows with recursive type aliases

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/call/constructor.md

@@ -291,6 +291,52 @@ a: int | MaybeInt = MaybeInt("42")  # OK
 b: int = MaybeInt("42")  # error: [invalid-assignment]
 ```
 
+### `__new__` returning a recursive alias union
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from __future__ import annotations
+
+type RecursiveNewReturn = RecursiveNew | RecursiveNewReturn
+
+class RecursiveNew:
+    def __new__(cls, value: int) -> RecursiveNewReturn:
+        raise NotImplementedError
+
+    def __init__(self, value: str) -> None: ...
+
+# error: [invalid-argument-type] "Argument to `RecursiveNew.__init__` is incorrect: Expected `str`, found `Literal[1]`"
+reveal_type(RecursiveNew(1))  # revealed: RecursiveNew
+```
+
+### Metaclass `__call__` returning a recursive alias union
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from __future__ import annotations
+
+type RecursiveMetaCallReturn = RecursiveMetaCall | RecursiveMetaCallReturn
+
+class RecursiveMeta(type):
+    def __call__(cls, value: int) -> RecursiveMetaCallReturn:
+        raise NotImplementedError
+
+class RecursiveMetaCall(metaclass=RecursiveMeta):
+    def __new__(cls, value: str) -> RecursiveMetaCall:
+        raise NotImplementedError
+
+# error: [invalid-argument-type] "Argument to constructor `RecursiveMetaCall.__new__` is incorrect: Expected `str`, found `Literal[1]`"
+reveal_type(RecursiveMetaCall(1))  # revealed: RecursiveMetaCall
+```
+
 ### `__new__` returning an intersection type
 
 ```py

crates/ty_python_semantic/resources/mdtest/call/dunder.md

@@ -171,6 +171,30 @@ class_with_callable_dunder = ClassWithNonMethodDunder()
 reveal_type(class_with_callable_dunder[0])  # revealed: str
 ```
 
+Recursive aliases in the dunder annotation should still terminate when we look up and call the
+dunder via `type(obj)`:
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from typing import reveal_type
+
+class G:
+    def __call__(self, key: int) -> "RecursiveGetItem":
+        return self
+
+type RecursiveGetItem = G | RecursiveGetItem
+
+class C:
+    __getitem__: RecursiveGetItem = G()
+
+def f(x: C):
+    reveal_type(x[0])  # revealed: G | Unknown
+```
+
 ## Dunders are looked up using the descriptor protocol
 
 Here, we demonstrate that the descriptor protocol is invoked when looking up a dunder method. Note

crates/ty_python_semantic/resources/mdtest/cycle.md

@@ -156,6 +156,33 @@ class Cyclic:
 reveal_type(Cyclic("").data)
 ```
 
+## Meta-type lookups through recursive aliases
+
+Recursive aliases can show up in class-body annotations and in operations that need the meta type,
+such as `__class__` lookup. These should not recurse indefinitely.
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from typing import reveal_type
+
+class G:
+    pass
+
+type RecursiveAlias = G | RecursiveAlias
+
+class C:
+    x: RecursiveAlias
+
+reveal_type(C.x)  # revealed: G
+
+def f(x: RecursiveAlias):
+    reveal_type(x.__class__)  # revealed: type[G]
+```
+
 ## Lazy cached property behind `hasattr`
 
 This pattern used to panic with "too many cycle iterations".

crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -439,6 +439,157 @@ def _(x: Bar[int]):
     reveal_type(x)  # revealed: int | list[int]
 ```
 
+### Recursive aliases in operations
+
+```py
+from typing import Callable, Iterator, Literal, TypedDict, overload
+from ty_extensions import all_members, has_member
+
+class RecursiveItem: ...
+
+type RecursiveUnion = RecursiveItem | RecursiveUnion
+
+def subscript_recursive_alias(x: RecursiveUnion):
+    # error: [not-subscriptable] "Cannot subscript object of type `RecursiveItem` with no `__getitem__` method"
+    reveal_type(x[0])  # revealed: Unknown
+
+class RecursiveIterableItem:
+    def __iter__(self) -> Iterator["RecursiveIterable"]:
+        return iter([self])
+
+type RecursiveIterable = RecursiveIterableItem | RecursiveIterable
+
+def iterate_recursive_alias(x: RecursiveIterable):
+    for y in x:
+        reveal_type(y)  # revealed: RecursiveIterableItem | Unknown
+
+def star_recursive_alias(x: RecursiveIterable):
+    def g(*args: object): ...
+
+    g(*x)
+
+class RecursiveCallable:
+    def __call__(self) -> "DunderRecursive":
+        return self
+
+type DunderRecursive = RecursiveCallable | DunderRecursive
+
+class HasRecursiveLen:
+    __len__: DunderRecursive = RecursiveCallable()
+
+def len_recursive_alias(x: HasRecursiveLen):
+    # error: [invalid-argument-type] "Argument to function `len` is incorrect: Expected `Sized`, found `HasRecursiveLen`"
+    reveal_type(len(x))  # revealed: int
+
+class RecursiveMembers:
+    attr: int
+
+type RecursiveMembersAlias = RecursiveMembers | RecursiveMembersAlias
+
+def list_recursive_alias_members(x: RecursiveMembersAlias):
+    all_members(x)
+    reveal_type(has_member(x, "attr"))  # revealed: Literal[False]
+
+class RecursiveAttribute:
+    attr: int
+
+type RecursiveAttributeAlias = RecursiveAttribute | RecursiveAttributeAlias
+
+def assign_recursive_alias_attribute(x: RecursiveAttributeAlias):
+    x.attr = 1
+
+def delete_recursive_alias_attribute(x: RecursiveAttributeAlias):
+    del x.attr
+
+class RecursiveKwargs(TypedDict):
+    kind: Literal["a"]
+    a: int
+
+type RecursiveKwargsAlias = RecursiveKwargs | RecursiveKwargsAlias
+
+def call_with_recursive_kwargs_alias(x: RecursiveKwargsAlias):
+    def g(a: int): ...
+
+    g(**x)
+
+def narrow_recursive_typed_dict_alias(x: RecursiveKwargsAlias):
+    if x["kind"] == "a":
+        reveal_type(x)  # revealed: RecursiveKwargs
+
+type RecursiveDecoratorReturn = Callable[[int], int] | RecursiveDecoratorReturn
+
+def recursive_decorator_return(fn: Callable[[int], int]) -> RecursiveDecoratorReturn: ...
+@recursive_decorator_return
+def decorated(x: int) -> int:
+    return x
+
+reveal_type(decorated)  # revealed: ((int, /) -> int) | Unknown
+
+class BaseWithMethod:
+    def method(self) -> None: ...
+
+class RecursiveSuperOwner(BaseWithMethod): ...
+
+type RecursiveSuperOwnerAlias = RecursiveSuperOwner | RecursiveSuperOwnerAlias
+
+def recursive_super_owner(x: RecursiveSuperOwnerAlias):
+    super(RecursiveSuperOwner, x).method()
+
+type RecursiveTuple = tuple[RecursiveTuple]
+
+@overload
+def overloaded_recursive_tuple(x: int) -> int: ...
+@overload
+def overloaded_recursive_tuple(x: str) -> str: ...
+def overloaded_recursive_tuple(x: object) -> object:
+    return x
+
+def expand_recursive_tuple_argument(x: RecursiveTuple):
+    # error: [no-matching-overload] "No overload of function `overloaded_recursive_tuple` matches arguments"
+    reveal_type(overloaded_recursive_tuple(x))  # revealed: Unknown
+
+@overload
+def overloaded_recursive_tuple_variadic(x: int) -> int: ...
+@overload
+def overloaded_recursive_tuple_variadic(x: int, y: int) -> str: ...
+def overloaded_recursive_tuple_variadic(*args: object) -> object:
+    return args
+
+def expand_recursive_variadic_tuple_argument(x: RecursiveTuple):
+    # error: [invalid-argument-type] "Argument to function `overloaded_recursive_tuple_variadic` is incorrect: Expected `int`, found `RecursiveTuple`"
+    reveal_type(overloaded_recursive_tuple_variadic(*x))  # revealed: Unknown
+
+type RecursiveClassInfo = type[int] | RecursiveClassInfo
+
+def narrow_recursive_classinfo(x: object, y: RecursiveClassInfo):
+    if isinstance(x, y):
+        reveal_type(x)  # revealed: object
+
+def narrow_recursive_subclassinfo(x: type[object], y: RecursiveClassInfo):
+    if issubclass(x, y):
+        reveal_type(x)  # revealed: type
+
+type RecursiveSingleValuedTuple = tuple[None, RecursiveSingleValuedTuple]
+
+def narrow_recursive_single_valued_tuple(x: object, y: RecursiveSingleValuedTuple):
+    if x == y:
+        reveal_type(x)  # revealed: object
+```
+
+### Parser-recovery operation regressions
+
+```py
+# error: [invalid-syntax] "Expected an expression"
+type CrashyOperation = | CrashyOperation
+
+def subscript_recovered_alias(x: CrashyOperation):
+    reveal_type(x[0])  # revealed: Unknown
+
+def iterate_recovered_alias(x: CrashyOperation):
+    for y in x:
+        reveal_type(y)  # revealed: Unknown
+```
+
 ### With legacy generic
 
 ```py

crates/ty_python_semantic/resources/mdtest/promotion.md

@@ -735,6 +735,19 @@ def _(a: A | None):
     return {}
 ```
 
+Callable promotion visits parameters with promotion disabled and returns with promotion enabled, so
+those two traversals should not share cached intersection results:
+
+```py
+from typing import Literal
+from ty_extensions import Intersection, Not
+
+def f(x: Intersection[int, Not[Literal[2]]]) -> Intersection[int, Not[Literal[2]]]:
+    return x
+
+reveal_type([f])  # revealed: list[(x: int & ~Literal[2]) -> int]
+```
+
 ## Module-literal types are not promoted
 
 Since module-literal types are "literal" types in a certain sense (each type is a singleton type),