[ty] WIP: handle recursive type inference properly

Cargo.toml

@@ -146,7 +146,7 @@ regex-automata = { version = "0.4.9" }
 rustc-hash = { version = "2.0.0" }
 rustc-stable-hash = { version = "0.1.2" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "25b3ef146cfa2615f4ec82760bd0c22b454d0a12", default-features = false, features = [
+salsa = { git = "https://github.com/mtshiba/salsa.git", rev = "9ea5289bc6a87943b8a8620df8ff429062c56af0", default-features = false, features = [
     "compact_str",
     "macros",
     "salsa_unstable",

crates/ruff_benchmark/benches/ty_walltime.rs

@@ -166,7 +166,7 @@ static PANDAS: Benchmark = Benchmark::new(
         max_dep_date: "2025-06-17",
         python_version: PythonVersion::PY312,
     },
-    3000,
+    3300,
 );
 
 static PYDANTIC: Benchmark = Benchmark::new(
@@ -197,7 +197,8 @@ static SYMPY: Benchmark = Benchmark::new(
         max_dep_date: "2025-06-17",
         python_version: PythonVersion::PY312,
     },
-    13000,
+    // TODO: With better decorator support, `__slots__` support, etc., it should be possible to reduce the number of errors considerably.
+    70000,
 );
 
 static TANJUN: Benchmark = Benchmark::new(

crates/ty_python_semantic/resources/corpus/cycle_into_callable.py

@@ -0,0 +1,17 @@
+# Regression test for https://github.com/astral-sh/ruff/issues/17371
+# panicked in commit d1088545a08aeb57b67ec1e3a7f5141159efefa5
+# error message:
+# dependency graph cycle when querying ClassType < 'db >::into_callable_(Id(1c00))
+
+try:
+    class foo[T: bar](object):
+        pass
+    bar = foo
+except Exception:
+    bar = lambda: 0
+def bar():
+    pass
+
+@bar()
+class bar:
+    pass

crates/ty_python_semantic/resources/corpus/divergent.py

@@ -0,0 +1,69 @@
+def f(cond: bool):
+    if cond:
+        result = ()
+        result += (f(cond),)
+        return result
+
+    return None
+
+reveal_type(f(True))
+
+def f(cond: bool):
+    if cond:
+        result = ()
+        result += (f(cond),)
+        return result
+
+    return None
+
+def f(cond: bool):
+    result = None
+    if cond:
+        result = ()
+        result += (f(cond),)
+
+    return result
+
+reveal_type(f(True))
+
+def f(cond: bool):
+    result = None
+    if cond:
+        result = [f(cond) for _ in range(1)]
+
+    return result
+
+reveal_type(f(True))
+
+class Foo:
+    def value(self):
+        return 1
+
+def unwrap(value):
+    if isinstance(value, Foo):
+        foo = value
+        return foo.value()
+    elif type(value) is tuple:
+        length = len(value)
+        if length == 0:
+            return ()
+        elif length == 1:
+            return (unwrap(value[0]),)
+        else:
+            result = []
+            for item in value:
+                result.append(unwrap(item))
+            return tuple(result)
+    else:
+        raise TypeError()
+
+def descent(x: int, y: int):
+    if x > y:
+        y, x = descent(y, x)
+        return x, y
+    if x == 1:
+        return (1, 0)
+    if y == 1:
+        return (0, 1)
+    else:
+        return descent(x-1, y-1)

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

@@ -79,7 +79,9 @@ def outer_sync():  # `yield` from is only valid syntax inside a synchronous func
         a: (yield from [1]),  # error: [invalid-type-form] "`yield from` expressions are not allowed in type expressions"
     ): ...
 
-async def baz(): ...
+async def baz():
+    yield
+
 async def outer_async():  # avoid unrelated syntax errors on `yield` and `await`
     def _(
         a: 1,  # error: [invalid-type-form] "Int literals are not allowed in this context in a type expression"

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -2369,6 +2369,24 @@
 
 reveal_type(B().x)  # revealed: Unknown | Literal[1]
 reveal_type(A().x)  # revealed: Unknown | Literal[1]
+
+class Base:
+    def flip(self) -> "Sub":
+        return Sub()
+
+class Sub(Base):
+    # TODO invalid override error
+    def flip(self) -> "Base":
+        return Base()
+
+class C2:
+    def __init__(self, x: Sub):
+        self.x = x
+
+    def replace_with(self, other: "C2"):
+        self.x = other.x.flip()
+
+reveal_type(C2(Sub()).x)  # revealed: Unknown | Base
 ```
 
 And cycles between many attributes:
@@ -2411,8 +2429,8 @@
         self.x6 = self.x1 + self.x2 + self.x3 + self.x4 + self.x5 + self.x7
         self.x7 = self.x1 + self.x2 + self.x3 + self.x4 + self.x5 + self.x6
 
         reveal_type(self.x1)  # revealed: Unknown | int
         reveal_type(self.x2)  # revealed: Unknown | int
         reveal_type(self.x3)  # revealed: Unknown | int
         reveal_type(self.x4)  # revealed: Unknown | int
         reveal_type(self.x5)  # revealed: Unknown | int

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

@@ -111,7 +111,7 @@ def _(flag: bool):
 
     # error: [call-non-callable] "Object of type `Literal["This is a string literal"]` is not callable"
     x = f(3)
-    reveal_type(x)  # revealed: Unknown
+    reveal_type(x)  # revealed: None | Unknown
 ```
 
 ## Union of binding errors
@@ -128,7 +128,7 @@ def _(flag: bool):
     # error: [too-many-positional-arguments] "Too many positional arguments to function `f1`: expected 0, got 1"
     # error: [too-many-positional-arguments] "Too many positional arguments to function `f2`: expected 0, got 1"
     x = f(3)
-    reveal_type(x)  # revealed: Unknown
+    reveal_type(x)  # revealed: None
 ```
 
 ## One not-callable, one wrong argument
@@ -146,7 +146,7 @@ def _(flag: bool):
     # error: [too-many-positional-arguments] "Too many positional arguments to function `f1`: expected 0, got 1"
     # error: [call-non-callable] "Object of type `C` is not callable"
     x = f(3)
-    reveal_type(x)  # revealed: Unknown
+    reveal_type(x)  # revealed: None | Unknown
 ```
 
 ## Union including a special-cased function

crates/ty_python_semantic/resources/mdtest/cycle.md

@@ -32,6 +32,29 @@ reveal_type(p.x)  # revealed: Unknown | int
 reveal_type(p.y)  # revealed: Unknown | int
 ```
 
+## Self-referential bare type alias
+
+```py
+A = list["A" | None]
+
+def f(x: A):
+    # TODO: should be `list[A | None]`?
+    reveal_type(x)  # revealed: list[Divergent]
+    # TODO: should be `A | None`?
+    reveal_type(x[0])  # revealed: Divergent
+```
+
+## Self-referential type variables
+
+```py
+from typing import Generic, TypeVar
+
+B = TypeVar("B", bound="Base")
+
+class Base(Generic[B]):
+    pass
+```
+
 ## Parameter default values
 
 This is a regression test for <https://github.com/astral-sh/ty/issues/1402>. When a parameter has a

crates/ty_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md

@@ -125,7 +125,8 @@ match obj:
 
 ```py
 class C:
-    def __await__(self): ...
+    def __await__(self):
+        yield
 
 # error: [invalid-syntax] "`return` statement outside of a function"
 return